LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x75c5e
movq %r14, %r15
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x75c7f
movq 0x8(%r15), %r12
cmpb $0x8, (%r12)
jne 0x75c95
cmpq %rbp, %r12
je 0x75c21
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 0x105649
movq 0xdb8(%rbx), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rcx
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0x75cff
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 0x75cb4
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %rbp, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r14, %r15
je 0x75cf0
incl %r9d
movq 0x10(%r14), %r14
cmpq %r15, %r14
jne 0x75ce4
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 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0x76393
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
jmp 0xdefe0
movq 0x1548(%rdi), %rdx
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0x763fb
movq 0x10(%rcx), %r8
movq 0x8(%r8), %rax
cmpb $0xb, (%rax)
jne 0x7640e
movq 0x8(%rax), %rdx
testq %rdx, %rdx
js 0x7642a
cmpq 0x8(%rsi), %rdx
jge 0x76453
movq 0x10(%r8), %rax
movq 0x8(%rax), %rbx
cmpb $0x8, (%rbx)
jne 0x764ae
movq 0x10(%rsi), %rax
movb 0x8(%rbx), %cl
movb %cl, (%rax,%rdx)
jmp 0x764a9
movq 0x1550(%rdi), %rdx
movl $0x13, %r8d
popq %rbx
jmp 0xeff2b
movq 0x1550(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
popq %rbx
jmp 0xf1ae
movq 0x1550(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0xd8524(%rip), %rdx     # 0x14e960
movq 0x140(%rdi), %r8
movq 0xe478e(%rip), %r9      # 0x15abd8
movq %rax, %rcx
popq %rbx
jmp 0xb31d
movq 0x1550(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0xd84fb(%rip), %rdx     # 0x14e960
movq 0xdc5d4(%rip), %rsi     # 0x152a40
movq 0x1ee8(%rdi), %r8
movq 0x10(%r8), %r8
movq %rcx, 0x8(%r8)
movq 0x10(%r8), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
popq %rbx
retq
movq 0x1550(%rdi), %rdx
movq %rbx, %rsi
movl $0x8, %r8d
movl $0x3, %r9d
jmp 0x76424
// File: /workspace/github_c_makefile_star2_O1/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, %rbp
movq %rdi, %rbx
movq 0x8(%rsi), %r15
cmpb $0x13, (%r15)
jne 0x765d2
movb $0x1, %al
movl %eax, 0x4(%rsp)
movq %rbp, %r14
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0x76601
movq 0x8(%r14), %r13
movb $0x1, %r12b
cmpq %r13, %r15
je 0x765bd
cmpb $0x13, (%r13)
jne 0x76548
testb $0x1, 0x4(%rsp)
je 0x765bd
movq 0x8(%r13), %rdx
cmpq 0x8(%r15), %rdx
jne 0x765c8
movq 0x10(%r13), %rdi
movq 0x10(%r15), %rsi
movq %rax, %r13
callq 0x9253a
movl %eax, 0x4(%rsp)
movq %r13, %rax
jmp 0x765bd
movq 0x1510(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x76567
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r15, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movl $0x1, %r9d
cmpq %rbp, %r14
je 0x765a6
movq %rbp, %rax
incl %r9d
movq 0x10(%rax), %rax
cmpq %r14, %rax
jne 0x7659a
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl $0x13, %r8d
callq 0xf1ae
xorl %r12d, %r12d
testb %r12b, %r12b
jne 0x764f1
jmp 0x76618
movl $0x0, 0x4(%rsp)
jmp 0x765bd
movq 0x1510(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae
testb $0x1, 0x4(%rsp)
je 0x76611
movq 0x118(%rbx), %rax
jmp 0x76618
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x767ed
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x7674a
movq %r14, %rdi
callq 0xb389
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 0xa305
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testq %r15, %r15
jle 0x7678e
movq %r12, %rsi
movq %r15, %rdx
callq 0x93e0
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r15)
movq %r15, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x767cb
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,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 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0x76860
movq %rsi, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c2fb
movq 0x1768(%rbx), %rdx
testb %al, %al
je 0x768b1
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1065e0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x76878
movq %rbx, %rdi
callq 0xb389
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 0x768f5
movq 0x18(%r15), %rax
movq %rax, 0x850(%rbx)
jmp 0x769a9
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 0xadd76(%rip), %rax     # 0x12464c
movq %rax, 0x10(%r8)
movq $0x2b, 0x8(%r8)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x103001
cmpq $0x0, 0x838(%rbx)
jne 0x7693b
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%rbx)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x76919
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%rbx), %r15
movq 0x18(%r15), %rax
movq %rax, 0x838(%rbx)
movl $0x0, 0x8(%r15)
movq 0x8c8(%rbx), %rax
addq $0x8, %rax
cmpq $0x10001, %rax          # imm = 0x10001
jb 0x76989
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, 0x8d0(%rbx)
movq $0x0, 0x8c8(%rbx)
movl $0x8, %eax
movq 0x8d0(%rbx), %rcx
addq 0x8c8(%rbx), %rcx
movq %rax, 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 0x8(%rbx), %rsi
cmpq %rsi, 0x10(%rbx)
jne 0x769f1
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movq %r14, (%rax,%rcx,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x76a3a
movq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x76a56
leaq 0xd7f1c(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x76a8f
movq 0x1758(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b739
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x76a6e
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_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 0x76d7f
movq 0x8(%r14), %rbx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xf83b
movq 0x10(%r14), %rcx
movq 0x10(%rax), %rdx
cmpq $0x7f, %rbx
jle 0x76de9
leaq 0xe67a3(%rip), %rsi     # 0x15d470
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
jg 0x76ccd
leaq 0x8(%rbx), %rdi
cmpq $0x9, %rdi
jl 0x76e0c
movzbl -0x1(%rcx,%rbx), %edi
movb (%rdi,%rsi), %dil
movb %dil, -0x1(%rdx,%rbx)
decq %rbx
testq %rbx, %rbx
jg 0x76d64
jmp 0x76e0c
movq 0x1508(%r15), %rbx
movq 0x90(%r15), %rax
movq 0x110(%r15), %r12
cmpq 0x98(%r15), %rax
ja 0x76da5
movq %r15, %rdi
callq 0xb389
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 0x9b739
testq %rbx, %rbx
jle 0x76e0c
xorl %esi, %esi
leaq 0xe6679(%rip), %rdi     # 0x15d470
movzbl (%rcx,%rsi), %r8d
movb (%r8,%rdi), %r8b
movb %r8b, (%rdx,%rsi)
incq %rsi
cmpq %rsi, %rbx
jne 0x76df7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_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 0x76f0d
movq 0x8(%r14), %rbx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xf83b
movq 0x10(%r14), %rcx
movq 0x10(%rax), %rdx
cmpq $0x7f, %rbx
jle 0x76f77
leaq 0xe3dc5(%rip), %rsi     # 0x15ac20
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
jg 0x76e5b
leaq 0x8(%rbx), %rdi
cmpq $0x9, %rdi
jl 0x76f9a
movzbl -0x1(%rcx,%rbx), %edi
movb (%rdi,%rsi), %dil
movb %dil, -0x1(%rdx,%rbx)
decq %rbx
testq %rbx, %rbx
jg 0x76ef2
jmp 0x76f9a
movq 0x1570(%r15), %rbx
movq 0x90(%r15), %rax
movq 0x110(%r15), %r12
cmpq 0x98(%r15), %rax
ja 0x76f33
movq %r15, %rdi
callq 0xb389
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 0x9b739
testq %rbx, %rbx
jle 0x76f9a
xorl %esi, %esi
leaq 0xe3c9b(%rip), %rdi     # 0x15ac20
movzbl (%rcx,%rsi), %r8d
movb (%r8,%rdi), %r8b
movb %r8b, (%rdx,%rsi)
incq %rsi
cmpq %rsi, %rbx
jne 0x76f85
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_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, %rbx
movq $0x0, 0x8(%rsp)
movq 0x8(%rsi), %r12
cmpb $0x13, (%r12)
jne 0x770f9
movq 0x8(%r12), %rax
movq %rax, (%rsp)
movq 0x10(%rcx), %rax
cmpq 0x110(%rbx), %rax
je 0x77022
movq 0x1580(%rbx), %rsi
leaq 0x8(%rsp), %r8
movq %rsp, %r9
movq %rbx, %rdi
movq %rcx, %rdx
movl $0x2, %ecx
callq 0xa0e7c
movq %rax, %r15
cmpq 0x140(%rbx), %rax
jne 0x770e8
movq (%rsp), %r14
movq 0x8(%rsp), %r13
subq %r13, %r14
addq 0x10(%r12), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7704b
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200013, (%r15)       # imm = 0x200013
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0xa305
movq %rax, 0x20(%r15)
movq (%rax), %rdi
movq %rdi, 0x10(%r15)
testq %r14, %r14
jle 0x7708f
movq %r13, %rsi
movq %r14, %rdx
callq 0x93e0
movq 0x10(%r15), %rax
movb $0x0, (%rax,%r14)
movq %r14, 0x8(%r15)
movq $0x0, 0x18(%r15)
movq 0x738(%rbx), %rbx
movq 0x8(%rbx), %rsi
cmpq %rsi, 0x10(%rbx)
jne 0x770cc
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movq %r15, (%rax,%rcx,8)
movq 0x10(%r15), %rax
movb $0x0, (%rax,%r14)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1580(%rbx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0x77149
movq 0x1558(%r14), %rdx
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1065e0
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x77161
movq %r14, %rdi
callq 0xb389
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 0x7719a
movq 0x18(%r15), %rax
movq %rax, 0x850(%r14)
jmp 0x7724e
cmpq $0x0, 0x838(%r14)
jne 0x771e0
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x771be
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r14), %r15
movq 0x18(%r15), %rax
movq %rax, 0x838(%r14)
movl $0x0, 0x8(%r15)
movq 0x8c8(%r14), %rax
addq $0x8, %rax
cmpq $0x10001, %rax          # imm = 0x10001
jb 0x7722e
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, 0x8d0(%r14)
movq $0x0, 0x8c8(%r14)
movl $0x8, %eax
movq 0x8d0(%r14), %rcx
addq 0x8c8(%r14), %rcx
movq %rax, 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 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x77296
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cons
static s7_pointer g_cons(s7_scheme *sc, s7_pointer args)
                {
#define H_cons "(cons a b) returns a pair containing a and b"
#define Q_cons s7_make_signature(sc, 3, sc->is_pair_symbol, sc->T, sc->T)

                    /* set_cdr(args, cadr(args));
                     * this is not safe -- it changes a variable's value directly:
                     *   (let ((lst (list 1 2))) (list (apply cons lst) lst)) -> '((1 . 2) (1 . 2))
                     */
                    s7_pointer x;
                    new_cell(sc, x, T_PAIR | T_SAFE_PROCEDURE);
                    set_car(x, car(args));
                    set_cdr(x, cadr(args));
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x79f14
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x79fb3
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsi)
retq
movq 0x14a8(%rdi), %rdx
movl $0x1, %r8d
jmp 0xeff2b
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_set_cdr
static s7_pointer g_set_cdr(s7_scheme *sc, s7_pointer args)
                {
#define H_set_cdr "(set-cdr! pair val) sets the pair's second element to val"
#define Q_set_cdr s7_make_signature(sc, 3, sc->T, sc->is_pair_symbol, sc->T)
                    s7_pointer p;

                    p = car(args);
                    if (!is_mutable_pair(p))
                        return(mutable_method_or_bust(sc, p, sc->set_cdr_symbol, args, T_PAIR, 1));

                    set_cdr(p, cadr(args));
                    return(cdr(p));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movl $0x10000ff, %eax        # imm = 0x10000FF
andl (%rsi), %eax
cmpl $0x1, %eax
jne 0x79fe5
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsi)
retq
movq 0x14b0(%rdi), %rdx
movl $0x1, %r8d
jmp 0xeff2b
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_caar
static s7_pointer g_caar(s7_scheme *sc, s7_pointer args)
                {
#define H_caar "(caar lst) returns (car (car lst)): (caar '((1 2))) -> 1"
#define Q_caar sc->pl_p

                    s7_pointer lst;
                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->caar_symbol, args, T_PAIR));
                    if (!is_pair(car(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caar_symbol, lst, car_a_list_string));
                    /* it makes no difference in timing to move lst here or below (i.e. lst=car(lst) then return(car(lst)) and so on) */
                    return(caar(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a00e
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a026
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xca8(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xca8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3531(%rip), %r8      # 0x15d570
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cadr
static s7_pointer g_cadr(s7_scheme *sc, s7_pointer args)
                {
#define H_cadr "(cadr lst) returns (car (cdr lst)): (cadr '(1 2 3)) -> 2"
#define Q_cadr sc->pl_p

                    s7_pointer lst;
                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->cadr_symbol, args, T_PAIR));
                    if (!is_pair(cdr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cadr_symbol, lst, cdr_a_list_string));
                    return(cadr(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a05e
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a076
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xce0(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xce0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe34e9(%rip), %r8      # 0x15d578
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cdar
static s7_pointer g_cdar(s7_scheme *sc, s7_pointer args)
                {
#define H_cdar "(cdar lst) returns (cdr (car lst)): (cdar '((1 2 3))) -> '(2 3)"
#define Q_cdar sc->pl_p

                    s7_pointer lst;
                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->cdar_symbol, args, T_PAIR));
                    if (!is_pair(car(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cdar_symbol, lst, car_a_list_string));
                    return(cdar(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a0ae
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a0c6
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd60(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd60(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3491(%rip), %r8      # 0x15d570
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cddr
static s7_pointer g_cddr(s7_scheme *sc, s7_pointer args)
                {
#define H_cddr "(cddr lst) returns (cdr (cdr lst)): (cddr '(1 2 3 4)) -> '(3 4)"
#define Q_cddr sc->pl_p

                    s7_pointer lst;
                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->cddr_symbol, args, T_PAIR));
                    if (!is_pair(cdr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cddr_symbol, lst, cdr_a_list_string));
                    return(cddr(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a0fe
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a116
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd98(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd98(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3449(%rip), %r8      # 0x15d578
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_caaar
static s7_pointer g_caaar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_caaar "(caaar lst) returns (car (car (car lst))): (caaar '(((1 2)))) -> 1"
#define Q_caaar sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->caaar_symbol, args, T_PAIR));
                    if (!is_pair(car(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caaar_symbol, lst, car_a_list_string));
                    if (!is_pair(caar(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caaar_symbol, lst, caar_a_list_string));
                    return(caaar(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a157
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a16f
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a18a
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc88(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xc88(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe33e8(%rip), %r8      # 0x15d570
jmp 0x7a1a3
movq 0xc88(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe33dd(%rip), %r8      # 0x15d580
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_caadr
static s7_pointer g_caadr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_caadr "(caadr lst) returns (car (car (cdr lst))): (caadr '(1 (2 3))) -> 2"
#define Q_caadr sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->caadr_symbol, args, T_PAIR));
                    if (!is_pair(cdr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caadr_symbol, lst, cdr_a_list_string));
                    if (!is_pair(cadr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caadr_symbol, lst, cadr_a_list_string));
                    return(caadr(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a1cb
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a1e3
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a1fe
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xca0(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xca0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe337c(%rip), %r8      # 0x15d578
jmp 0x7a217
movq 0xca0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3371(%rip), %r8      # 0x15d588
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cadar
static s7_pointer g_cadar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cadar "(cadar lst) returns (car (cdr (car lst))): (cadar '((1 2 3))) -> 2"
#define Q_cadar sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->cadar_symbol, args, T_PAIR));
                    if (!is_pair(car(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cadar_symbol, lst, car_a_list_string));
                    if (!is_pair(cdar(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cadar_symbol, lst, cdar_a_list_string));
                    return(cadar(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a23f
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a257
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a272
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcc0(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xcc0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3300(%rip), %r8      # 0x15d570
jmp 0x7a28b
movq 0xcc0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3305(%rip), %r8      # 0x15d590
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cdaar
static s7_pointer g_cdaar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cdaar "(cdaar lst) returns (cdr (car (car lst))): (cdaar '(((1 2 3)))) -> '(2 3)"
#define Q_cdaar sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->cdaar_symbol, args, T_PAIR));
                    if (!is_pair(car(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cdaar_symbol, lst, car_a_list_string));
                    if (!is_pair(caar(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cdaar_symbol, lst, caar_a_list_string));
                    return(cdaar(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a2b3
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a2cb
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a2e6
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd40(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd40(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe328c(%rip), %r8      # 0x15d570
jmp 0x7a2ff
movq 0xd40(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3281(%rip), %r8      # 0x15d580
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_caddr
static s7_pointer g_caddr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_caddr "(caddr lst) returns (car (cdr (cdr lst))): (caddr '(1 2 3 4)) -> 3"
#define Q_caddr sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->caddr_symbol, args, T_PAIR));
                    if (!is_pair(cdr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caddr_symbol, lst, cdr_a_list_string));
                    if (!is_pair(cddr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caddr_symbol, lst, cddr_a_list_string));
                    return(caddr(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a327
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a33f
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a35a
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcd8(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xcd8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3220(%rip), %r8      # 0x15d578
jmp 0x7a373
movq 0xcd8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3225(%rip), %r8      # 0x15d598
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cdddr
static s7_pointer g_cdddr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cdddr "(cdddr lst) returns (cdr (cdr (cdr lst))): (cdddr '(1 2 3 4)) -> '(4)"
#define Q_cdddr sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->cdddr_symbol, args, T_PAIR));
                    if (!is_pair(cdr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cdddr_symbol, lst, cdr_a_list_string));
                    if (!is_pair(cddr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cdddr_symbol, lst, cddr_a_list_string));
                    return(cdddr(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a39b
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a3b3
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a3ce
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd90(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd90(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe31ac(%rip), %r8      # 0x15d578
jmp 0x7a3e7
movq 0xd90(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe31b1(%rip), %r8      # 0x15d598
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cdadr
static s7_pointer g_cdadr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cdadr "(cdadr lst) returns (cdr (car (cdr lst))): (cdadr '(1 (2 3 4))) -> '(3 4)"
#define Q_cdadr sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->cdadr_symbol, args, T_PAIR));
                    if (!is_pair(cdr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cdadr_symbol, lst, cdr_a_list_string));
                    if (!is_pair(cadr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cdadr_symbol, lst, cadr_a_list_string));
                    return(cdadr(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a40f
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a427
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a442
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd58(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd58(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3138(%rip), %r8      # 0x15d578
jmp 0x7a45b
movq 0xd58(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe312d(%rip), %r8      # 0x15d588
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cddar
static s7_pointer g_cddar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cddar "(cddar lst) returns (cdr (cdr (car lst))): (cddar '((1 2 3 4))) -> '(3 4)"
#define Q_cddar sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->cddar_symbol, args, T_PAIR));
                    if (!is_pair(car(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cddar_symbol, lst, car_a_list_string));
                    if (!is_pair(cdar(lst))) return(simple_wrong_type_argument_with_type(sc, sc->cddar_symbol, lst, cdar_a_list_string));
                    return(cddar(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a483
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a49b
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a4b6
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd78(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe30bc(%rip), %r8      # 0x15d570
jmp 0x7a4cf
movq 0xd78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe30c1(%rip), %r8      # 0x15d590
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_caaaar
static s7_pointer g_caaaar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_caaaar "(caaaar lst) returns (car (car (car (car lst)))): (caaaar '((((1 2))))) -> 1"
#define Q_caaaar sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->caaaar_symbol, args, T_PAIR));
                    if (!is_pair(car(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caaaar_symbol, lst, car_a_list_string));
                    if (!is_pair(caar(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caaaar_symbol, lst, caar_a_list_string));
                    if (!is_pair(caaar(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caaaar_symbol, lst, caaar_a_list_string));
                    return(caaaar(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a500
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a518
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a533
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a54e
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc78(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xc78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe303f(%rip), %r8      # 0x15d570
jmp 0x7a567
movq 0xc78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3034(%rip), %r8      # 0x15d580
jmp 0x7a567
movq 0xc78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe3039(%rip), %r8      # 0x15d5a0
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_caaadr
static s7_pointer g_caaadr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_caaadr "(caaadr lst) returns (car (car (car (cdr lst)))): (caaadr '(1 ((2 3)))) -> 2"
#define Q_caaadr sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->caaadr_symbol, args, T_PAIR));
                    if (!is_pair(cdr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caaadr_symbol, lst, cdr_a_list_string));
                    if (!is_pair(cadr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caaadr_symbol, lst, cadr_a_list_string));
                    if (!is_pair(caadr(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caaadr_symbol, lst, caadr_a_list_string));
                    return(caaadr(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a598
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a5b0
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a5cb
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a5e6
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc80(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xc80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2faf(%rip), %r8      # 0x15d578
jmp 0x7a5ff
movq 0xc80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2fa4(%rip), %r8      # 0x15d588
jmp 0x7a5ff
movq 0xc80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2fa9(%rip), %r8      # 0x15d5a8
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_caadar
static s7_pointer g_caadar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_caadar "(caadar lst) returns (car (car (cdr (car lst)))): (caadar '((1 (2 3)))) -> 2"
#define Q_caadar sc->pl_p

                    lst = car(args);
                    if (!is_pair(lst)) return(method_or_bust_one_arg(sc, lst, sc->caadar_symbol, args, T_PAIR));
                    if (!is_pair(car(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caadar_symbol, lst, car_a_list_string));
                    if (!is_pair(cdar(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caadar_symbol, lst, cdar_a_list_string));
                    if (!is_pair(cadar(lst))) return(simple_wrong_type_argument_with_type(sc, sc->caadar_symbol, lst, cadar_a_list_string));
                    return(caadar(lst));
                }

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x7a630
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a648
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a663
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a67e
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc90(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xc90(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2f0f(%rip), %r8      # 0x15d570
jmp 0x7a697
movq 0xc90(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2f14(%rip), %r8      # 0x15d590
jmp 0x7a697
movq 0xc90(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2f19(%rip), %r8      # 0x15d5b0
movq %rax, %rdx
jmp 0xfac8