LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x8a6b0
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x58(%rsp), %rax
movq 0xdb8(%rax), %rdx
movq 0x50(%rsp), %rcx
movl $0x8, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x60(%rsp)
jmp 0x8a838
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x8a827
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14430
testb $0x1, %al
jne 0x8a7db
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq 0xdb8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x8a746
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xc5450
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rsp), %rcx
movl %eax, %r9d
movl $0x8, %r8d
callq 0x13c50
movq %rax, 0x60(%rsp)
jmp 0x8a838
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x40(%rsp), %rax
je 0x8a812
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rax
movq 0xdb8(%rax), %rcx
callq 0x1c2320
movq %rax, 0x60(%rsp)
jmp 0x8a838
jmp 0x8a814
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
jmp 0x8a6be
movq 0x58(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x8b8ac
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1548(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x20(%rsp)
jmp 0x8b8cd
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
callq 0x16d530
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x8c16c
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x1760(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x20(%rsp)
jmp 0x8c18d
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x144d0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x8c214
movq 0x28(%rsp), %rdi
leaq 0x1682b8(%rip), %rsi    # 0x1f44b9
xorl %eax, %eax
movl %eax, %edx
callq 0x144d0
movq %rax, 0x30(%rsp)
jmp 0x8c2b9
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x31a40
testb $0x1, %al
jne 0x8c295
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x1768(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x16744e(%rip), %rsi    # 0x1f36b7
movl $0x2b, %edx
callq 0xb880
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rax, %r8
callq 0x1ba7e0
movq %rax, 0x30(%rsp)
jmp 0x8c2b9
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x1768(%rax), %rdx
callq 0x1c42f0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x8c329
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x1758(%rax), %rdx
movq 0x30(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0x40(%rsp)
jmp 0x8c3e7
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x8c35e
movq 0x20(%rsp), %rcx
leaq 0x18a12c(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x8c3d4
jmp 0x8c360
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x8c384
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xb, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x8cf48
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x1580(%rax), %rdx
movq 0x30(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x40(%rsp)
jmp 0x8d012
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x8cfbd
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x1580(%rax), %rsi
movq 0x30(%rsp), %rdx
movl $0x2, %ecx
leaq 0x18(%rsp), %r8
leaq 0x10(%rsp), %r9
callq 0xda710
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x140(%rcx), %rax
je 0x8cfbb
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x8d012
jmp 0x8cfbd
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq (%rsp), %rsi
addq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x144d0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x8e352
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_car
static s7_pointer g_car(s7_scheme *sc, s7_pointer args)
                {
#define H_car "(car pair) returns the first element of the pair"
#define Q_car sc->pl_p

                    s7_pointer lst;
                    lst = car(args);
                    if (is_pair(lst))
                        return(car(lst));
                    return(method_or_bust_one_arg(sc, lst, sc->car_symbol, args, T_PAIR));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x8e3e9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x8e414
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xd20(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_cdr
static s7_pointer g_cdr(s7_scheme *sc, s7_pointer args)
                {
#define H_cdr "(cdr pair) returns the second element of the pair"
#define Q_cdr sc->pl_p

                    s7_pointer lst;
                    lst = car(args);
                    if (is_pair(lst))
                        return(cdr(lst));
                    return(method_or_bust_one_arg(sc, lst, sc->cdr_symbol, args, T_PAIR));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x8e459
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x8e484
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xda0(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x10000ff, %rax        # imm = 0x10000FF
cmpq $0x1, %rax
je 0x8e4f0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x14a8(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x192ea0
movq %rax, 0x20(%rsp)
jmp 0x8e514
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x10000ff, %rax        # imm = 0x10000FF
cmpq $0x1, %rax
je 0x8e580
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x14b0(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x192ea0
movq %rax, 0x20(%rsp)
jmp 0x8e5a4
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e606
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xca8(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8e662
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e650
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xca8(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196adc(%rip), %r8     # 0x225120
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8e662
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e6c6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xce0(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8e722
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e710
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xce0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196a24(%rip), %r8     # 0x225128
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8e722
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e786
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xd60(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8e7e2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e7d0
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd60(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x19695c(%rip), %r8     # 0x225120
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8e7e2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e846
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xd98(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8e8a2
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e890
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd98(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1968a4(%rip), %r8     # 0x225128
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8e8a2
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e909
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xc88(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8e9b7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e953
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc88(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1967d9(%rip), %r8     # 0x225120
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8e9b7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8e9a1
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc88(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x19679b(%rip), %r8     # 0x225130
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8e9b7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ea29
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xca0(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8ead7
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ea73
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xca0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1966c1(%rip), %r8     # 0x225128
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ead7
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8eac1
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xca0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196683(%rip), %r8     # 0x225138
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ead7
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8eb49
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xcc0(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8ebf7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8eb93
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xcc0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196599(%rip), %r8     # 0x225120
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ebf7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ebe1
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xcc0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x19656b(%rip), %r8     # 0x225140
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ebf7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ec69
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xd40(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8ed17
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ecb3
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd40(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196479(%rip), %r8     # 0x225120
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ed17
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ed01
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd40(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x19643b(%rip), %r8     # 0x225130
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ed17
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ed89
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xcd8(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8ee37
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8edd3
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xcd8(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196361(%rip), %r8     # 0x225128
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ee37
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ee21
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xcd8(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196333(%rip), %r8     # 0x225148
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ee37
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8eea9
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xd90(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8ef57
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8eef3
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd90(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196241(%rip), %r8     # 0x225128
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ef57
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8ef41
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd90(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196213(%rip), %r8     # 0x225148
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8ef57
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8efc9
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xd58(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8f077
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f013
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd58(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x196121(%rip), %r8     # 0x225128
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f077
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f061
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd58(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1960e3(%rip), %r8     # 0x225138
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f077
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f0e9
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xd78(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8f197
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f133
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd78(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195ff9(%rip), %r8     # 0x225120
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f197
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f181
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xd78(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195fcb(%rip), %r8     # 0x225140
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f197
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f209
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xc78(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8f310
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f256
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc78(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195ed9(%rip), %r8     # 0x225120
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f310
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f2a4
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc78(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195e98(%rip), %r8     # 0x225130
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f310
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f2f6
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc78(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195e66(%rip), %r8     # 0x225150
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f310
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f379
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xc80(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8f480
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f3c6
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc80(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195d71(%rip), %r8     # 0x225128
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f480
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f414
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc80(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195d30(%rip), %r8     # 0x225138
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f480
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f466
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc80(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195cfe(%rip), %r8     # 0x225158
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f480
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f4e9
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xc90(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
jmp 0x8f5f0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f536
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc90(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195bf9(%rip), %r8     # 0x225120
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f5f0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f584
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc90(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195bc8(%rip), %r8     # 0x225140
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f5f0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x8f5d6
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xc90(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x195b96(%rip), %r8     # 0x225160
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0x8f5f0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)