LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x6ec15
movq %rsi, %r14
movq $-0x1, %rbp
movq %rsi, %r13
movq 0x8(%r13), %r15
cmpb $0xb, (%r15)
jne 0x6ec64
andq 0x8(%r15), %rbp
movq 0x10(%r13), %r13
cmpq %rax, %r13
jne 0x6ebe8
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x6ec1c
leaq 0xd7d41(%rip), %rax     # 0x146950
movq (%rax,%rbp,8), %rax
jmp 0x6ec55
movq $-0x1, %rbp
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6ec3b
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %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 0x6ed12
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x6ec8e
leaq 0xd7cc8(%rip), %rax     # 0x146950
movq (%rax,%rbp,8), %r12
jmp 0x6eccf
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6ecb3
movq %rbx, %rdi
movq %rdx, %r12
callq 0xa550
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 0x6ecf4
movq %rbx, %rdi
movq %rdx, %rbp
callq 0xa550
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 0x6ed29
incl %r9d
movq 0x10(%r14), %r14
cmpq %r13, %r14
jne 0x6ed1d
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 0xe42d
// File: /workspace/github_c_makefile_star2_O3/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 0x6ed78
movq 0x8(%rsi), %r14
cmpq $-0x800, %r14           # imm = 0xF800
notq %r14
jb 0x6ed94
leaq 0xd7bde(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x6edcd
movq 0x12b0(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95069
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6edb3
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6ee1d
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x6ee35
movq 0x8(%rsi), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0xfc2e0
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x6ee5a
leaq 0xd7b39(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x6ee93
movq 0xbd8(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
movl $0x1, %r9d
jmp 0x6ee4e
movq 0xbd8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe42d
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6ee79
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6f4df
movq %rdi, %rbx
cmpl $0xc, %eax
je 0x6f472
cmpl $0xb, %eax
jne 0x6f4ee
cvtsi2sdq 0x8(%r14), %xmm0
jmp 0x6f498
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 0x6f4c3
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
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 0x6f51b
movq %rbx, %rdi
callq 0xa550
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 0xe5e60(%rip), %r8      # 0x1553a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfa261
// File: /workspace/github_c_makefile_star2_O3/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 0x6f596
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
jns 0x6f578
notq %rdi
callq 0xfc3d9
movslq %eax, %r14
cmpl $0x7ff, %r14d           # imm = 0x7FF
ja 0x6f5b2
leaq 0xd73c0(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x6f5eb
movq 0x1718(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95069
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6f5d1
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6fa81
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x6fa99
pushq %rbx
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0x6fab4
cmpq $0x3e, %rcx
ja 0x6fb0c
testb $0x1, 0xdb1ff(%rip)     # 0x14ac60
je 0x6fb0c
movq 0x8(%rsi), %rax
xorl %edx, %edx
btq %rcx, %rax
setae %dl
movq 0x118(%rdi,%rdx,8), %rbx
jmp 0x6fb1e
movq 0x12a0(%rdi), %rdx
movl $0xb, %r8d
movl $0x1, %r9d
jmp 0xe42d
movq 0x12a0(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
jmp 0xe42d
movq 0x12a0(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0xd6e9a(%rip), %rdx     # 0x146960
movq 0xdaf7b(%rip), %rsi     # 0x14aa48
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 0x38dfa
jmp 0x6fb1e
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_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x1560(%rdi), %rdx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x701cb
movq 0x10(%rcx), %rdi
movl $0xa, %eax
cmpb $0x1, (%rdi)
jne 0x701e6
movq 0x8(%rdi), %r8
cmpb $0xb, (%r8)
jne 0x70225
movq 0x8(%r8), %rax
leaq -0x11(%rax), %rcx
cmpq $-0x10, %rcx
ja 0x701e6
movq 0x8(%rdx), %rax
movq 0xd67de(%rip), %rcx     # 0x146960
movq 0xe54a7(%rip), %rdx     # 0x155630
movq 0x1ee8(%rbx), %rsi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38dfa
jmp 0x7021a
movq %rbx, %rdi
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe42d
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x70213
cmpb $0x0, (%rsi)
je 0x70213
movq %rbx, %rdi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x91b3a
movq %rax, %r14
movzbl (%rax), %eax
leaq 0xda763(%rip), %rcx     # 0x14a970
cmpb $0x0, (%rax,%rcx)
jne 0x7021a
movq 0x120(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r8, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
jmp 0x701da
// File: /workspace/github_c_makefile_star2_O3/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 0x70255
movzbl 0x9(%rsi), %eax
movq 0xda808(%rip), %rcx     # 0x14aa58
movq (%rcx,%rax,8), %rax
retq
movq 0xdf0(%rdi), %rdx
movl $0x8, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 0x7028e
movzbl 0x8(%rsi), %eax
leaq 0xe51f2(%rip), %rcx     # 0x155470
movzbl (%rax,%rcx), %eax
movq 0xda7cf(%rip), %rcx     # 0x14aa58
movq (%rcx,%rax,8), %rax
retq
movq 0xdb0(%rdi), %rdx
movl $0x8, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 0x702bc
movzbl 0x8(%rsi), %eax
leaq 0xd6699(%rip), %rcx     # 0x146950
movq (%rcx,%rax,8), %rax
retq
movq 0xde8(%rdi), %rdx
movl $0x8, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 0x702f3
movzbl 0x13(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1028(%rdi), %rdx
movl $0x8, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 0x70321
movzbl 0x14(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1010(%rdi), %rdx
movl $0x8, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 0x7034f
movzbl 0x10(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1008(%rdi), %rdx
movl $0x8, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 0x7037d
movzbl 0x11(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1018(%rdi), %rdx
movl $0x8, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 0x703ab
movzbl 0x12(%rsi), %eax
xorl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
movq 0x1030(%rdi), %rdx
movl $0x8, %r8d
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_chars_are_equal
static s7_pointer g_chars_are_equal(s7_scheme *sc, s7_pointer args)
    {
#define H_chars_are_equal "(char=? char ...) returns #t if all the character arguments are equal"
#define Q_chars_are_equal sc->pcl_bc

        s7_pointer x, y;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rbp
cmpb $0x8, (%rbp)
jne 0x70418
movq %r14, %r15
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x70439
movq 0x8(%r15), %r12
cmpb $0x8, (%r12)
jne 0x7044f
cmpq %rbp, %r12
je 0x703db
movq 0xdb8(%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfc48e
movq 0xdb8(%rbx), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rcx
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0x704b9
movq 0x118(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdb8(%rbx), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x70475
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %rbp, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r14, %r15
je 0x704aa
incl %r9d
movq 0x10(%r14), %r14
cmpq %r15, %r14
jne 0x7049e
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x8, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_position
static s7_pointer g_string_position(s7_scheme *sc, s7_pointer args)
    {
#define H_string_position "(string-position str1 str2 (start 0)) returns the starting position of str1 in str2 or #f"
#define Q_string_position s7_make_signature(sc, 4, s7_make_signature(sc, 2, sc->is_integer_symbol, sc->not_symbol), sc->is_string_symbol, sc->is_string_symbol, sc->is_integer_symbol)
        const char *s1, *s2, *p2;
        s7_int start = 0;
        s7_pointer s1p, s2p;

        s1p = car(args);
        if (!is_string(s1p))
            return(method_or_bust(sc, s1p, sc->string_position_symbol, args, T_STRING, 1));

        s2p = cadr(args);
        if (!is_string(s2p))
            return(method_or_bust(sc, s2p, sc->string_position_symbol, args, T_STRING, 2));

        if (is_pair(cddr(args)))
        {
            s7_pointer arg3;
            arg3 = caddr(args);
            if (!s7_is_integer(arg3))
                return(method_or_bust(sc, arg3, sc->string_position_symbol, args, T_INTEGER, 3));
            start = s7_integer(arg3);
            if (start < 0)
                return(wrong_type_argument_with_type(sc, sc->string_position_symbol, 3, caddr(args), a_non_negative_integer_string));
        }

        if (string_length(s1p) == 0)
            return(sc->F);
        s1 = string_value(s1p);
        s2 = string_value(s2p);
        if (start >= string_length(s2p))
            return(sc->F);

        p2 = strstr((const char *)(s2 + start), s1);
        if (!p2) return(sc->F);
        return(make_integer(sc, p2 - s2));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x70782
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rax
cmpb $0x13, (%rax)
jne 0x7079a
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0x707bd
movq 0x8(%rdx), %r10
cmpb $0xb, (%r10)
jne 0x7080a
movq 0x8(%r10), %rdi
testq %rdi, %rdi
jns 0x707bf
movq 0x1540(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xd6204(%rip), %rdx     # 0x146968
movq 0x140(%rbx), %r8
movq 0xe2466(%rip), %r9      # 0x152bd8
movq %rbx, %rdi
movq %r10, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xa4e4
movq 0x1540(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0x707b3
movq 0x1540(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x13, %r8d
movl $0x2, %r9d
popq %rbx
popq %r14
popq %r15
jmp 0xe42d
xorl %edi, %edi
cmpq $0x0, 0x8(%rsi)
je 0x707fd
cmpq 0x8(%rax), %rdi
jge 0x707fd
movq 0x10(%rax), %r15
movq 0x10(%rsi), %rsi
addq %r15, %rdi
callq 0x8700
testq %rax, %rax
je 0x707fd
movq %rax, %r14
subq %r15, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x70825
leaq 0xd6159(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x70804
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x1540(%rbx), %rdx
movq %rbx, %rdi
movq %r10, %rsi
movl $0xb, %r8d
movl $0x3, %r9d
jmp 0x707b3
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x70844
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0x70804
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_ref
static s7_pointer g_string_ref(s7_scheme *sc, s7_pointer args)
    {
#define H_string_ref "(string-ref str index) returns the character at the index-th element of the string str"
#define Q_string_ref s7_make_signature(sc, 3, sc->is_char_symbol, sc->is_string_symbol, sc->is_integer_symbol)

        s7_pointer strng;
        strng = car(args);
        if (!is_string(strng))
            return(method_or_bust(sc, strng, sc->string_ref_symbol, args, T_STRING, 1));
        return(string_ref_1(sc, strng, cadr(args)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x70b82
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
jmp 0xd6723
movq 0x1548(%rdi), %rdx
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_set
static s7_pointer g_string_set(s7_scheme *sc, s7_pointer args)
    {
#define H_string_set "(string-set! str index chr) sets the index-th element of the string str to the character chr"
#define Q_string_set s7_make_signature(sc, 4, sc->is_char_symbol, sc->is_string_symbol, sc->is_integer_symbol, sc->is_char_symbol)

        s7_pointer strng, c, index;
        char *str;
        s7_int ind;

        strng = car(args);
        if (!is_mutable_string(strng))
            return(mutable_method_or_bust(sc, strng, sc->string_set_symbol, args, T_STRING, 1));

        index = cadr(args);
        if (!s7_is_integer(index))
            return(method_or_bust(sc, index, sc->string_set_symbol, args, T_INTEGER, 2));
        ind = s7_integer(index);
        if (ind < 0)
            return(wrong_type_argument_with_type(sc, sc->string_set_symbol, 2, index, a_non_negative_integer_string));
        if (ind >= string_length(strng))
            return(out_of_range(sc, sc->string_set_symbol, small_int(2), index, its_too_large_string));

        str = string_value(strng);
        c = caddr(args);
        if (!s7_is_character(c))
            return(method_or_bust(sc, c, sc->string_set_symbol, args, T_CHARACTER, 3));

        str[ind] = (char)s7_character(c);
        return(c);
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movl $0x10000ff, %eax        # imm = 0x10000FF
andl (%rsi), %eax
cmpl $0x13, %eax
jne 0x70bea
movq 0x10(%rcx), %r8
movq 0x8(%r8), %rax
cmpb $0xb, (%rax)
jne 0x70bfd
movq 0x8(%rax), %rdx
testq %rdx, %rdx
js 0x70c19
cmpq 0x8(%rsi), %rdx
jge 0x70c42
movq 0x10(%r8), %rax
movq 0x8(%rax), %rbx
cmpb $0x8, (%rbx)
jne 0x70c9d
movq 0x10(%rsi), %rax
movb 0x8(%rbx), %cl
movb %cl, (%rax,%rdx)
jmp 0x70c98
movq 0x1550(%rdi), %rdx
movl $0x13, %r8d
popq %rbx
jmp 0xe7180
movq 0x1550(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
popq %rbx
jmp 0xe42d
movq 0x1550(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0xd5d35(%rip), %rdx     # 0x146960
movq 0x140(%rdi), %r8
movq 0xe1f9f(%rip), %r9      # 0x152bd8
movq %rax, %rcx
popq %rbx
jmp 0xa4e4
movq 0x1550(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0xd5d0c(%rip), %rdx     # 0x146960
movq 0xd9de5(%rip), %rsi     # 0x14aa40
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 0x38dfa
movq %rbx, %rax
popq %rbx
retq
movq 0x1550(%rdi), %rdx
movq %rbx, %rsi
movl $0x8, %r8d
movl $0x3, %r9d
jmp 0x70c13
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_strings_are_equal
static s7_pointer g_strings_are_equal(s7_scheme *sc, s7_pointer args)
    {
#define H_strings_are_equal "(string=? str ...) returns #t if all the string arguments are equal"
#define Q_strings_are_equal sc->pcl_bs

        /* C-based check stops at null, but we can have embedded nulls.
         *   (let ((s1 "1234") (s2 "1245")) (string-set! s1 1 #\null) (string-set! s2 1 #\null) (string=? s1 s2))
         */
        s7_pointer x, y;
        bool happy = true;

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

        for (x = cdr(args); is_pair(x); x = cdr(x))
        {
            s7_pointer p;
            p = car(x);
            if (y != p)
            {
                if (!is_string(p))
                    return(method_or_bust(sc, p, sc->string_eq_symbol, cons(sc, y, x), T_STRING, position_of(x, args)));
                if (happy)
                    happy = scheme_strings_are_equal(p, y);
            }
        }
        if (!happy)
            return(sc->F);
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
cmpb $0x13, (%r15)
jne 0x70d38
movq 0x10(%r14), %rbp
cmpb $0x1, (%rbp)
jne 0x70d22
movb $0x1, %al
movq 0x8(%rbp), %r12
cmpq %r12, %r15
je 0x70d10
cmpb $0x13, (%r12)
jne 0x70d67
testb $0x1, %al
je 0x70d10
movq 0x8(%r12), %rdx
cmpq 0x8(%r15), %rdx
jne 0x70d0e
movq 0x10(%r12), %rdi
movq 0x10(%r15), %rsi
callq 0x8c146
jmp 0x70d10
xorl %eax, %eax
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
je 0x70cdf
testb $0x1, %al
je 0x70dd3
movq 0x118(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1510(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe42d
movq 0x1510(%rbx), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x70d8d
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r15, 0x8(%rcx)
movq %rbp, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r14, %rbp
je 0x70dc2
incl %r9d
movq 0x10(%r14), %r14
cmpq %rbp, %r14
jne 0x70db6
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl $0x13, %r8d
jmp 0x70d54
movq 0x120(%rbx), %rax
jmp 0x70d29
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_copy
static s7_pointer g_string_copy(s7_scheme *sc, s7_pointer args)
    {
#define H_string_copy "(string-copy str) returns a copy of its string argument"
#define Q_string_copy s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_string_symbol)
        s7_pointer p;
        p = car(args);
        if (!is_string(p))
            return(method_or_bust(sc, p, sc->string_copy_symbol, args, T_STRING, 1));
        return(make_string_with_length(sc, string_value(p), string_length(p)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x70fa5
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x70f09
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200013, (%rbx)       # imm = 0x200013
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x9357
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testq %r15, %r15
jle 0x70f4a
movq %r12, %rsi
movq %r15, %rdx
callq 0x83e0
movq 0x10(%rbx), %rdi
movb $0x0, (%rdi,%r15)
movq %r15, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x70f8a
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1760(%r14), %rdx
movq %r14, %rdi
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_list_to_string
static s7_pointer g_list_to_string(s7_scheme *sc, s7_pointer args)
    {
#define H_list_to_string "(list->string lst) appends all the list's characters into one string; (apply string lst)"
#define Q_list_to_string s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_proper_list_symbol)

        if (is_null(car(args)))
            return(make_string_with_length(sc, "", 0));

        if (!s7_is_proper_list(sc, car(args)))
            return(method_or_bust_with_type_one_arg(sc, car(args), sc->list_to_string_symbol, args,
                        wrap_string(sc, "a (proper, non-circular) list of characters", 43)));
        return(g_string_1(sc, car(args), sc->list_to_string_symbol));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r15
cmpq 0x110(%rdi), %r15
je 0x71018
movq %rsi, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39d6f
movq 0x1768(%rbx), %rdx
testb %al, %al
je 0x71069
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xfd416
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x71037
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200013, (%r14)       # imm = 0x200013
movq 0x850(%rbx), %r15
testq %r15, %r15
je 0x710ad
movq 0x18(%r15), %rax
movq %rax, 0x850(%rbx)
jmp 0x7114d
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %r8
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0xaa6ce(%rip), %rax     # 0x11b75c
movq %rax, 0x10(%r8)
movq $0x2b, 0x8(%r8)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xfa261
movq 0x838(%rbx), %r15
testq %r15, %r15
jne 0x710f8
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, %r15
movq %rax, 0x838(%rbx)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x710d6
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x18(%r15), %rax
movq %rax, 0x838(%rbx)
movq 0x8c8(%rbx), %rcx
leaq 0x8(%rcx), %rdx
cmpq $0x10000, %rdx          # imm = 0x10000
jbe 0x71131
movl $0x10000, %edi          # imm = 0x10000
callq 0x8480
movq %rax, 0x8d0(%rbx)
movl $0x8, %edx
xorl %ecx, %ecx
jmp 0x71138
movq 0x8d0(%rbx), %rax
addq %rax, %rcx
movq %rdx, 0x8c8(%rbx)
movq %rcx, (%r15)
movl $0x3, 0x8(%r15)
movq $0x1, 0x10(%r15)
movq %r15, 0x20(%r14)
movq (%r15), %rax
movq %rax, 0x10(%r14)
movb $0x0, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x18(%r14)
movq 0x738(%rbx), %rbx
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
cmpq 0x8(%rbx), %rsi
jne 0x7119c
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%rbx)
movq 0x10(%rbx), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, (%rax,%rsi,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_length
static s7_pointer g_string_length(s7_scheme *sc, s7_pointer args)
    {
#define H_string_length "(string-length str) returns the length of the string str"
#define Q_string_length s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_string_symbol)
        s7_pointer p;
        p = car(args);
        if (!is_string(p))
            return(method_or_bust_one_arg(sc, p, sc->string_length_symbol, args, T_STRING));
        return(make_integer(sc, string_length(p)));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x711de
movq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x711fa
leaq 0xd5778(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x71233
movq 0x1758(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95069
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x71219
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_downcase
static s7_pointer g_string_downcase(s7_scheme *sc, s7_pointer args)
    {
#define H_string_downcase "(string-downcase str) returns the lower case version of str."
#define Q_string_downcase sc->pcl_s

        s7_pointer p, newstr;
        s7_int i, len;
        uint8_t *nstr, *ostr;

        p = car(args);
        if (!is_string(p))
            return(method_or_bust_one_arg(sc, p, sc->string_downcase_symbol, list_1(sc, p), T_STRING));
        len = string_length(p);
        newstr = make_empty_string(sc, len, 0);

        ostr = (uint8_t *)string_value(p);
        nstr = (uint8_t *)string_value(newstr);

        if (len >= 128)
        {
            i = len - 1;
            while (i >= 8)
                LOOP_8(nstr[i] = lowers[(uint8_t)ostr[i]]; i--);
            while (i >= 0) {nstr[i] = lowers[(uint8_t)ostr[i]]; i--;}
        }
        else
        {
            for (i = 0; i < len; i++)
                nstr[i] = lowers[(uint8_t)ostr[i]];
        }
        return(newstr);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x8(%rsi), %r14
cmpb $0x13, (%r14)
jne 0x71531
movq 0x8(%r14), %rbx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xeab0
movq 0x10(%r14), %rcx
movq 0x10(%rax), %rdx
cmpq $0x7f, %rbx
jle 0x7159b
leaq 0xe3fe0(%rip), %rsi     # 0x155470
movq %rbx, %rdi
movzbl -0x1(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x1(%rdx,%rbx)
movzbl -0x2(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x2(%rdx,%rbx)
movzbl -0x3(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x3(%rdx,%rbx)
movzbl -0x4(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x4(%rdx,%rbx)
movzbl -0x5(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x5(%rdx,%rbx)
movzbl -0x6(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x6(%rdx,%rbx)
movzbl -0x7(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x7(%rdx,%rbx)
movzbl -0x8(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x8(%rdx,%rbx)
addq $-0x8, %rbx
cmpq $0x10, %rdi
ja 0x71490
movzbl -0x1(%rcx,%rbx), %edi
movb (%rdi,%rsi), %dil
movb %dil, -0x1(%rdx,%rbx)
decq %rbx
jne 0x71519
jmp 0x715be
movq 0x1508(%r15), %rbx
movq 0x90(%r15), %rax
movq 0x110(%r15), %r12
cmpq 0x98(%r15), %rax
ja 0x7155e
movq %r15, %rdi
callq 0xa550
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x13, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x95069
testq %rbx, %rbx
jle 0x715be
xorl %esi, %esi
leaq 0xe3ec7(%rip), %rdi     # 0x155470
movzbl (%rcx,%rsi), %r8d
movb (%r8,%rdi), %r8b
movb %r8b, (%rdx,%rsi)
incq %rsi
cmpq %rsi, %rbx
jne 0x715a9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_upcase
static s7_pointer g_string_upcase(s7_scheme *sc, s7_pointer args)
    {
#define H_string_upcase "(string-upcase str) returns the upper case version of str."
#define Q_string_upcase sc->pcl_s

        s7_pointer p, newstr;
        s7_int i, len;
        uint8_t *nstr, *ostr;

        p = car(args);
        if (!is_string(p))
            return(method_or_bust_one_arg(sc, p, sc->string_upcase_symbol, list_1(sc, p), T_STRING));
        len = string_length(p);
        newstr = make_empty_string(sc, len, 0);

        ostr = (uint8_t *)string_value(p);
        nstr = (uint8_t *)string_value(newstr);

        if (len >= 128)
        {
            i = len - 1;
            while (i >= 8)
                LOOP_8(nstr[i] = uppers[(uint8_t)ostr[i]]; i--);
            while (i >= 0) {nstr[i] = uppers[(uint8_t)ostr[i]]; i--;}
        }
        else
        {
            for (i = 0; i < len; i++)
                nstr[i] = uppers[(uint8_t)ostr[i]];
        }
        return(newstr);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x8(%rsi), %r14
cmpb $0x13, (%r14)
jne 0x716ae
movq 0x8(%r14), %rbx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xeab0
movq 0x10(%r14), %rcx
movq 0x10(%rax), %rdx
cmpq $0x7f, %rbx
jle 0x71718
leaq 0xe1613(%rip), %rsi     # 0x152c20
movq %rbx, %rdi
movzbl -0x1(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x1(%rdx,%rbx)
movzbl -0x2(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x2(%rdx,%rbx)
movzbl -0x3(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x3(%rdx,%rbx)
movzbl -0x4(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x4(%rdx,%rbx)
movzbl -0x5(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x5(%rdx,%rbx)
movzbl -0x6(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x6(%rdx,%rbx)
movzbl -0x7(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x7(%rdx,%rbx)
movzbl -0x8(%rcx,%rbx), %r8d
movb (%r8,%rsi), %r8b
movb %r8b, -0x8(%rdx,%rbx)
addq $-0x8, %rbx
cmpq $0x10, %rdi
ja 0x7160d
movzbl -0x1(%rcx,%rbx), %edi
movb (%rdi,%rsi), %dil
movb %dil, -0x1(%rdx,%rbx)
decq %rbx
jne 0x71696
jmp 0x7173b
movq 0x1570(%r15), %rbx
movq 0x90(%r15), %rax
movq 0x110(%r15), %r12
cmpq 0x98(%r15), %rax
ja 0x716db
movq %r15, %rdi
callq 0xa550
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x13, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x95069
testq %rbx, %rbx
jle 0x7173b
xorl %esi, %esi
leaq 0xe14fa(%rip), %rdi     # 0x152c20
movzbl (%rcx,%rsi), %r8d
movb (%r8,%rdi), %r8b
movb %r8b, (%rdx,%rsi)
incq %rsi
cmpq %rsi, %rbx
jne 0x71726
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_substring
static s7_pointer g_substring(s7_scheme *sc, s7_pointer args)
    {
#define H_substring "(substring str start (end (length str))) returns the portion of the string str between start and \
end: (substring \"01234\" 1 2) -> \"1\""
#define Q_substring s7_make_circular_signature(sc, 2, 3, sc->is_string_symbol, sc->is_string_symbol, sc->is_integer_symbol)

        s7_pointer x, str;
        s7_int start = 0, end, len;
        char *s;

        str = car(args);
        if (!is_string(str))
            return(method_or_bust(sc, str, sc->substring_symbol, args, T_STRING, 1));

        end = string_length(str);
        if (!is_null(cdr(args)))
        {
            x = start_and_end(sc, sc->substring_symbol, args, 2, &start, &end);
            if (x != sc->unused) return(x);
        }
        s = string_value(str);
        len = end - start;
        x = make_string_with_length(sc, (char *)(s + start), len);
        string_value(x)[len] = 0;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movq 0x8(%rsi), %r12
cmpb $0x13, (%r12)
jne 0x717ca
movq 0x8(%r12), %rbx
movq %rbx, (%rsp)
movq 0x10(%rcx), %rax
cmpq 0x110(%r14), %rax
je 0x717f5
movq 0x1580(%r14), %rsi
leaq 0x8(%rsp), %r8
movq %rsp, %r9
movq %r14, %rdi
movq %rcx, %rdx
movl $0x2, %ecx
callq 0x9a55e
movq %rax, %r15
cmpq 0x140(%r14), %rax
jne 0x718b3
movq (%rsp), %rbx
movq 0x8(%rsp), %r13
jmp 0x717f8
movq 0x1580(%r14), %rdx
movq %r14, %rdi
movq %r12, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe42d
xorl %r13d, %r13d
subq %r13, %rbx
addq 0x10(%r12), %r13
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x7181f
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r15
movq $0x200013, (%r15)       # imm = 0x200013
leaq 0x1(%rbx), %rsi
movq %r14, %rdi
callq 0x9357
movq %rax, 0x20(%r15)
movq (%rax), %rdi
movq %rdi, 0x10(%r15)
testq %rbx, %rbx
jle 0x71860
movq %r13, %rsi
movq %rbx, %rdx
callq 0x83e0
movq 0x10(%r15), %rdi
movb $0x0, (%rdi,%rbx)
movq %rbx, 0x8(%r15)
movq $0x0, 0x18(%r15)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x7189f
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %r15, (%rax,%rsi,8)
movq 0x10(%r15), %rax
movb $0x0, (%rax,%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string
static s7_pointer g_string(s7_scheme *sc, s7_pointer args)
    {
#define H_string "(string chr...) appends all its character arguments into one string"
#define Q_string s7_make_circular_signature(sc, 1, 2, sc->is_string_symbol, sc->is_char_symbol)

        if (is_null(args))
            return(make_string_with_length(sc, "", 0));
        return(g_string_1(sc, args, sc->string_symbol));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpq %rsi, 0x110(%rdi)
je 0x718e9
movq 0x1558(%r14), %rdx
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xfd416
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x71908
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200013, (%rbx)       # imm = 0x200013
movq 0x850(%r14), %r15
testq %r15, %r15
je 0x7193a
movq 0x18(%r15), %rax
movq %rax, 0x850(%r14)
jmp 0x719da
movq 0x838(%r14), %r15
testq %r15, %r15
jne 0x71985
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, %r15
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x71963
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x18(%r15), %rax
movq %rax, 0x838(%r14)
movq 0x8c8(%r14), %rcx
leaq 0x8(%rcx), %rdx
cmpq $0x10000, %rdx          # imm = 0x10000
jbe 0x719be
movl $0x10000, %edi          # imm = 0x10000
callq 0x8480
movq %rax, 0x8d0(%r14)
movl $0x8, %edx
xorl %ecx, %ecx
jmp 0x719c5
movq 0x8d0(%r14), %rax
addq %rax, %rcx
movq %rdx, 0x8c8(%r14)
movq %rcx, (%r15)
movl $0x3, 0x8(%r15)
movq $0x1, 0x10(%r15)
movq %r15, 0x20(%rbx)
movq (%r15), %rax
movq %rax, 0x10(%rbx)
movb $0x0, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x71a29
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_set_car
static s7_pointer g_set_car(s7_scheme *sc, s7_pointer args)
                {
#define H_set_car "(set-car! pair val) sets the pair's first element to val"
#define Q_set_car s7_make_signature(sc, 3, sc->T, sc->is_pair_symbol, sc->T)
                    s7_pointer p;

                    p = car(args);
                    if (!is_mutable_pair(p)) /* this is currently 2.5x slower than is_pair */
                        return(mutable_method_or_bust(sc, p, sc->set_car_symbol, args, T_PAIR, 1));
                    set_car(p, cadr(args));
                    return(car(p));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movl $0x10000ff, %eax        # imm = 0x10000FF
andl (%rsi), %eax
cmpl $0x1, %eax
jne 0x743e7
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsi)
retq
movq 0x14a8(%rdi), %rdx
movl $0x1, %r8d
jmp 0xe7180