LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x5e0a9
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e0bf
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e0da
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd78(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6498(%rip), %r8      # 0x124570
jmp 0x5e0f3
movq 0xd78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc649d(%rip), %r8      # 0x124590
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x5e124
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e13a
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e155
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e170
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc78(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xc78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc641d(%rip), %r8      # 0x124570
jmp 0x5e189
movq 0xc78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6412(%rip), %r8      # 0x124580
jmp 0x5e189
movq 0xc78(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6417(%rip), %r8      # 0x1245a0
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x5e1ba
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e1d0
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e1eb
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e206
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc80(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xc80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc638f(%rip), %r8      # 0x124578
jmp 0x5e21f
movq 0xc80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6384(%rip), %r8      # 0x124588
jmp 0x5e21f
movq 0xc80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6389(%rip), %r8      # 0x1245a8
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x5e250
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e266
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e281
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e29c
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc90(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xc90(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc62f1(%rip), %r8      # 0x124570
jmp 0x5e2b5
movq 0xc90(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc62f6(%rip), %r8      # 0x124590
jmp 0x5e2b5
movq 0xc90(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc62fb(%rip), %r8      # 0x1245b0
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cadaar
static s7_pointer g_cadaar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cadaar "(cadaar lst) returns (car (cdr (car (car lst)))): (cadaar '(((1 2 3)))) -> 2"
#define Q_cadaar sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e2e6
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e2fc
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e317
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e332
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcb0(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xcb0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc625b(%rip), %r8      # 0x124570
jmp 0x5e34b
movq 0xcb0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6250(%rip), %r8      # 0x124580
jmp 0x5e34b
movq 0xcb0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6275(%rip), %r8      # 0x1245c0
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_caaddr
static s7_pointer g_caaddr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_caaddr "(caaddr lst) returns (car (car (cdr (cdr lst)))): (caaddr '(1 2 (3 4))) -> 3"
#define Q_caaddr sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e37c
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e392
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e3ad
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e3c8
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc98(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xc98(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc61cd(%rip), %r8      # 0x124578
jmp 0x5e3e1
movq 0xc98(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc61d2(%rip), %r8      # 0x124598
jmp 0x5e3e1
movq 0xc98(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc61d7(%rip), %r8      # 0x1245b8
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cadddr
static s7_pointer g_cadddr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cadddr "(cadddr lst) returns (car (cdr (cdr (cdr lst)))): (cadddr '(1 2 3 4 5)) -> 4"
#define Q_cadddr sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e412
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e428
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e443
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e45e
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcd0(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xcd0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6137(%rip), %r8      # 0x124578
jmp 0x5e477
movq 0xcd0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc613c(%rip), %r8      # 0x124598
jmp 0x5e477
movq 0xcd0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6161(%rip), %r8      # 0x1245d8
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cadadr
static s7_pointer g_cadadr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cadadr "(cadadr lst) returns (car (cdr (car (cdr lst)))): (cadadr '(1 (2 3 4))) -> 3"
#define Q_cadadr sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e4a8
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e4be
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e4d9
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e4f4
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcb8(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xcb8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc60a1(%rip), %r8      # 0x124578
jmp 0x5e50d
movq 0xcb8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6096(%rip), %r8      # 0x124588
jmp 0x5e50d
movq 0xcb8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc60bb(%rip), %r8      # 0x1245c8
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_caddar
static s7_pointer g_caddar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_caddar "(caddar lst) returns (car (cdr (cdr (car lst)))): (caddar '((1 2 3 4))) -> 3"
#define Q_caddar sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e53e
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e554
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e56f
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e58a
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcc8(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xcc8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6003(%rip), %r8      # 0x124570
jmp 0x5e5a3
movq 0xcc8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc6008(%rip), %r8      # 0x124590
jmp 0x5e5a3
movq 0xcc8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc602d(%rip), %r8      # 0x1245d0
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cdaaar
static s7_pointer g_cdaaar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cdaaar "(cdaaar lst) returns (cdr (car (car (car lst)))): (cdaaar '((((1 2 3))))) -> '(2 3)"
#define Q_cdaaar sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e5d4
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e5ea
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e605
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e620
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd30(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd30(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5f6d(%rip), %r8      # 0x124570
jmp 0x5e639
movq 0xd30(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5f62(%rip), %r8      # 0x124580
jmp 0x5e639
movq 0xd30(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5f67(%rip), %r8      # 0x1245a0
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cdaadr
static s7_pointer g_cdaadr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cdaadr "(cdaadr lst) returns (cdr (car (car (cdr lst)))): (cdaadr '(1 ((2 3 4)))) -> '(3 4)"
#define Q_cdaadr sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e66a
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e680
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e69b
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e6b6
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd38(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd38(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5edf(%rip), %r8      # 0x124578
jmp 0x5e6cf
movq 0xd38(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5ed4(%rip), %r8      # 0x124588
jmp 0x5e6cf
movq 0xd38(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5ed9(%rip), %r8      # 0x1245a8
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cdadar
static s7_pointer g_cdadar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cdadar "(cdadar lst) returns (cdr (car (cdr (car lst)))): (cdadar '((1 (2 3 4)))) -> '(3 4)"
#define Q_cdadar sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e700
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e716
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e731
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e74c
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd48(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd48(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5e41(%rip), %r8      # 0x124570
jmp 0x5e765
movq 0xd48(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5e46(%rip), %r8      # 0x124590
jmp 0x5e765
movq 0xd48(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5e4b(%rip), %r8      # 0x1245b0
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cddaar
static s7_pointer g_cddaar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cddaar "(cddaar lst) returns (cdr (cdr (car (car lst)))): (cddaar '(((1 2 3 4)))) -> '(3 4)"
#define Q_cddaar sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e796
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e7ac
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e7c7
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e7e2
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd68(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd68(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5dab(%rip), %r8      # 0x124570
jmp 0x5e7fb
movq 0xd68(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5da0(%rip), %r8      # 0x124580
jmp 0x5e7fb
movq 0xd68(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5dc5(%rip), %r8      # 0x1245c0
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cdaddr
static s7_pointer g_cdaddr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cdaddr "(cdaddr lst) returns (cdr (car (cdr (cdr lst)))): (cdaddr '(1 2 (3 4 5))) -> '(4 5)"
#define Q_cdaddr sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e82c
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e842
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e85d
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e878
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd50(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd50(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5d1d(%rip), %r8      # 0x124578
jmp 0x5e891
movq 0xd50(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5d22(%rip), %r8      # 0x124598
jmp 0x5e891
movq 0xd50(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5d27(%rip), %r8      # 0x1245b8
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cddddr
static s7_pointer g_cddddr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cddddr "(cddddr lst) returns (cdr (cdr (cdr (cdr lst)))): (cddddr '(1 2 3 4 5)) -> '(5)"
#define Q_cddddr sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e8c2
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e8d8
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e8f3
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e90e
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd88(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd88(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5c87(%rip), %r8      # 0x124578
jmp 0x5e927
movq 0xd88(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5c8c(%rip), %r8      # 0x124598
jmp 0x5e927
movq 0xd88(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5cb1(%rip), %r8      # 0x1245d8
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cddadr
static s7_pointer g_cddadr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cddadr "(cddadr lst) returns (cdr (cdr (car (cdr lst)))): (cddadr '(1 (2 3 4 5))) -> '(4 5)"
#define Q_cddadr sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e958
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5e96e
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e989
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5e9a4
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd70(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd70(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5bf1(%rip), %r8      # 0x124578
jmp 0x5e9bd
movq 0xd70(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5be6(%rip), %r8      # 0x124588
jmp 0x5e9bd
movq 0xd70(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5c0b(%rip), %r8      # 0x1245c8
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cdddar
static s7_pointer g_cdddar(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer lst;
#define H_cdddar "(cdddar lst) returns (cdr (cdr (cdr (car lst)))): (cdddar '((1 2 3 4 5))) -> '(4 5)"
#define Q_cdddar sc->pl_p

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

// Assembly:
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5e9ee
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5ea04
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5ea1f
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x5ea3a
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd80(%rdi), %rdx
pushq $0x1
popq %r8
movq %rax, %rsi
jmp 0x77745
movq 0xd80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5b53(%rip), %r8      # 0x124570
jmp 0x5ea53
movq 0xd80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5b58(%rip), %r8      # 0x124590
jmp 0x5ea53
movq 0xd80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xc5b7d(%rip), %r8      # 0x1245d0
movq %rax, %rdx
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_assv
static s7_pointer g_assv(s7_scheme *sc, s7_pointer args)        /* g_assv is called by g_assoc below */
                {
                    s7_pointer x, y, z;
#define H_assv "(assv obj alist) returns the key-value pair associated (via eqv?) with the key obj in the association list alist"
#define Q_assv Q_assq

                    x = car(args);
                    y = cadr(args);
                    if (!is_pair(y))
                    {
                        if (is_null(y)) return(sc->F);
                        return(method_or_bust_with_type(sc, y, sc->assv_symbol, list_2(sc, x, y), an_association_list_string, 2));
                    }

                    if (is_simple(x))
                        return(s7_assq(sc, x, y));

                    z = y;
                    while (true)
                    {
                        /* here we can't play the assq == game because s7_is_eqv thinks it's getting a legit s7 object */
                        if ((is_pair(car(y))) && (s7_is_eqv(x, caar(y)))) return(car(y));
                        y = cdr(y);
                        if (!is_pair(y)) return(sc->F);

                        if ((is_pair(car(y))) && (s7_is_eqv(x, caar(y)))) return(car(y));
                        y = cdr(y);
                        if (!is_pair(y)) return(sc->F);

                        z = cdr(z);
                        if (z == y) return(sc->F);
                    }
                    return(sc->F); /* not reached */
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
cmpb $0x1, (%r14)
jne 0x5eab9
movzbl (%r15), %eax
leaq 0xc3608(%rip), %rcx     # 0x1220a0
cmpb $0x0, (%rax,%rcx)
je 0x5eb51
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2db7b
movq 0x110(%rbx), %r13
cmpq %r13, %r14
je 0x5ebab
movq 0xc00(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5eaef
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0xc5aba(%rip), %r8      # 0x1245f0
pushq $0x2
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
movq %r14, %r13
movq 0x8(%r13), %r12
cmpb $0x1, (%r12)
jne 0x5eb70
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x32e3b
testb %al, %al
jne 0x5ebb2
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
jne 0x5ebab
movq 0x8(%r13), %r12
cmpb $0x1, (%r12)
jne 0x5eb97
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x32e3b
testb %al, %al
jne 0x5ebb2
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
jne 0x5ebab
movq 0x10(%r14), %r14
cmpq %r13, %r14
jne 0x5eb54
movq 0x120(%rbx), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_memq
static s7_pointer g_memq(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer x, y;
#define H_memq "(memq obj list) looks for obj in list and returns the list from that point if it is found, otherwise #f. memq uses eq?"
#define Q_memq sc->pl_tl

                    x = car(args);
                    y = cadr(args);
                    if (is_pair(y))
                        return(s7_memq(sc, x, y));
                    if (is_null(y))
                        return(sc->F);
                    return(method_or_bust_with_type(sc, y, sc->memq_symbol, list_2(sc, x, y), a_list_string, 2));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
cmpb $0x1, (%r14)
jne 0x5f2d8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2dc6b
movq 0x110(%rbx), %r13
cmpq %r13, %r14
je 0x5f370
movq 0x1338(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5f30e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0xc528b(%rip), %r8      # 0x1245e0
pushq $0x2
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
movq 0x120(%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_memv
static s7_pointer g_memv(s7_scheme *sc, s7_pointer args)
                {
#define H_memv "(memv obj list) looks for obj in list and returns the list from that point if it is found, otherwise #f. memv uses eqv?"
#define Q_memv sc->pl_tl
                    s7_pointer x, y, z;

                    x = car(args);
                    y = cadr(args);
                    if (!is_pair(y))
                    {
                        if (is_null(y)) return(sc->F);
                        return(method_or_bust_with_type(sc, y, sc->memv_symbol, list_2(sc, x, y), a_list_string, 2));
                    }

                    if (is_simple(x)) return(s7_memq(sc, x, y));
                    if (s7_is_number(x)) return(memv_number(sc, x, y));

                    z = y;
                    while (true)
                    {
                        if (s7_is_eqv(x, car(y))) return(y);
                        y = cdr(y);
                        if (!is_pair(y)) return(sc->F);

                        if (s7_is_eqv(x, car(y))) return(y);
                        y = cdr(y);
                        if (!is_pair(y)) return(sc->F);

                        z = cdr(z);
                        if (z == y) return(sc->F);
                    }
                    return(sc->F); /* not reached */
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
cmpb $0x1, (%r14)
jne 0x5f3cb
movzbl (%r15), %eax
leaq 0xc2cf6(%rip), %rcx     # 0x1220a0
cmpb $0x1, (%rax,%rcx)
jne 0x5f463
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2dc6b
movq 0x110(%rbx), %r13
cmpq %r13, %r14
je 0x5f4cd
movq 0x1340(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x5f401
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0xc5198(%rip), %r8      # 0x1245e0
pushq $0x2
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
leaq 0xba506(%rip), %rcx     # 0x119970
cmpb $0x0, (%rax,%rcx)
je 0x5f487
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcac73
movq %r14, %r12
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x32e3b
testb %al, %al
jne 0x5f4d4
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x5f4cd
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x32e3b
testb %al, %al
jne 0x5f4d4
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x5f4cd
movq 0x10(%r14), %r14
cmpq %r12, %r14
jne 0x5f48a
movq 0x120(%rbx), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_list_ref
static s7_pointer g_list_ref(s7_scheme *sc, s7_pointer args)
                {
#define H_list_ref "(list-ref lst i ...) returns the i-th element (0-based) of the list"
#define Q_list_ref s7_make_circular_signature(sc, 2, 3, sc->T, sc->is_pair_symbol, sc->is_integer_symbol)

                    /* (let ((L '((1 2 3) (4 5 6)))) (list-ref L 1 2))
                       (define (lref L . args)
                       (if (null? (cdr args))
                       (list-ref L (car args))
                       (apply lref (list-ref L (car args)) (cdr args))))
                       */
                    s7_pointer lst, inds;

                    lst = car(args);
                    if (!is_pair(lst))
                        return(method_or_bust(sc, lst, sc->list_ref_symbol, args, T_PAIR, 1));

                    inds = cdr(args);
                    while (true)
                    {
                        lst = list_ref_1(sc, lst, car(inds));
                        if (is_null(cdr(inds)))
                            return(lst);
                        inds = cdr(inds);
                        if (!is_pair(lst))
                            return(implicit_index(sc, lst, inds)); /* 9-Jan-19 */
                    }
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x5fd16
movq 0x10(%rcx), %r14
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa96db
movq 0x10(%r14), %r14
cmpq 0x110(%rbx), %r14
je 0x5fd36
cmpb $0x1, (%rax)
je 0x5fce0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa8fcd
movq 0x1258(%rbx), %rdx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %rax, %rsi
movl %r8d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcd70
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_make_list
static s7_pointer g_make_list(s7_scheme *sc, s7_pointer args)
                {
#define H_make_list "(make-list length (initial-element #f)) returns a list of 'length' elements whose value is 'initial-element'."
#define Q_make_list s7_make_signature(sc, 3, sc->is_proper_list_symbol, sc->is_integer_symbol, sc->T)

                    s7_pointer init, n;
                    s7_int len;

                    n = car(args);
                    if (!s7_is_integer(n))
                        return(method_or_bust(sc, n, sc->make_list_symbol, args, T_INTEGER, 1));

                    len = s7_integer(n);
#if WITH_GMP
                    if ((len == 0) && (!s7_is_zero(n)))
                        return(s7_out_of_range_error(sc, "make-list", 1, n, "big integer is too big for s7_int"));
#endif
                    if ((len < 0) || (len > sc->max_list_length))
                        return(out_of_range(sc, sc->make_list_symbol, small_int(1), n, (len < 0) ? its_negative_string : its_too_large_string));
                    if (len == 0) return(sc->nil);          /* what about (make-list 0 123)? */

                    if (is_pair(cdr(args)))
                        init = cadr(args);
                    else init = sc->F;
                    return(make_list(sc, (int32_t)len, init));
                }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rcx
cmpb $0xb, (%rcx)
jne 0x5ff7b
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
js 0x5ff4c
cmpq 0x2b0(%rdi), %rsi
jle 0x5ff95
testq %rsi, %rsi
movq 0x1308(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xb59f7(%rip), %rdx     # 0x115958
leaq 0xb9ae0(%rip), %rax     # 0x119a48
leaq 0xb9ad1(%rip), %r8      # 0x119a40
cmovsq %rax, %r8
movq (%r8), %r8
jmp 0xcb8f
movq 0x1308(%rdi), %rdx
pushq $0xb
popq %r8
pushq $0x1
popq %r9
movq %rcx, %rsi
movq %rax, %rcx
jmp 0xcd70
testq %rsi, %rsi
je 0x5ffb8
movq 0x10(%rax), %rax
leaq 0x8(%rax), %rcx
leaq 0x120(%rdi), %rdx
cmpb $0x1, (%rax)
cmoveq %rcx, %rdx
movq (%rdx), %rdx
jmp 0x2ddf5
movq 0x110(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_list_to_vector
static s7_pointer g_list_to_vector(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer p;
#define H_list_to_vector "(list->vector lst) returns a vector containing the elements of lst; (apply vector lst)"
#define Q_list_to_vector s7_make_signature(sc, 2, sc->is_vector_symbol, sc->is_proper_list_symbol)

                    p = car(args);
                    sc->temp3 = p;
                    if (is_null(p))
                        return(s7_make_vector(sc, 0));

                    if (!s7_is_proper_list(sc, p))
                        return(method_or_bust_with_type_one_arg(sc, p, sc->list_to_vector_symbol, list_1(sc, p), a_proper_list_string));

                    p = g_vector(sc, p);
                    sc->temp3 = sc->nil;
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq %r14, 0x508(%rdi)
movq 0x110(%rdi), %r12
cmpq %r12, %r14
je 0x624cb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2db34
testb %al, %al
je 0x624e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62b20
movq 0x110(%rbx), %rcx
movq %rcx, 0x508(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e473
movq 0x1770(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x62506
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xbf6ed(%rip), %r8      # 0x121c18
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc736d
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_vector_length
static s7_pointer g_vector_length(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer vec;
#define H_vector_length "(vector-length v) returns the length of vector v"
#define Q_vector_length s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_vector_symbol)

                    vec = car(args);
                    if (!is_any_vector(vec))
                        return(method_or_bust_one_arg(sc, vec, sc->vector_length_symbol, args, T_VECTOR));

                    return(make_integer(sc, vector_length(vec)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leaq 0xb76b5(%rip), %rdx     # 0x119c20
cmpb $0x0, (%rax,%rdx)
je 0x6258b
movq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x625a5
leaq 0xb33cb(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x625de
movq 0x1778(%rbx), %rdx
pushq $0x15
popq %r8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77745
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x625c4
movq %rbx, %rdi
callq 0x9c27
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_O2/BernardTatin[P]s7sh/s7.c
// Function: g_vector_ref
static s7_pointer g_vector_ref(s7_scheme *sc, s7_pointer args)
                {
#define H_vector_ref "(vector-ref v ... i) returns the i-th element of vector v."
#define Q_vector_ref s7_make_circular_signature(sc, 2, 3, sc->T, sc->is_vector_symbol, sc->is_integer_symbol)

                    s7_pointer vec;

                    vec = car(args);
                    if (!is_any_vector(vec))
                        return(method_or_bust(sc, vec, sc->vector_ref_symbol, args, T_VECTOR, 1));
                    return(vector_ref_1(sc, vec, cdr(args))); /* 19-Jan-19 */
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leaq 0xb7482(%rip), %rdx     # 0x119c20
cmpb $0x0, (%rax,%rdx)
je 0x627ad
movq 0x10(%rcx), %rdx
jmp 0xa8d11
movq 0x1660(%rdi), %rdx
pushq $0x15
popq %r8
pushq $0x1
popq %r9
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_vector
static s7_pointer g_vector(s7_scheme *sc, s7_pointer args)
                {
#define H_vector "(vector ...) returns a vector whose elements are the arguments"
#define Q_vector s7_make_circular_signature(sc, 1, 2, sc->is_vector_symbol, sc->T)

                    s7_int len;
                    s7_pointer vec;

                    len = safe_list_length(args); /* was s7_list_length but don't we ensure that arglists are proper? */
                    vec = make_simple_vector(sc, len);
                    if (len > 0)
                    {
                        s7_int i;
                        s7_pointer x;
                        for (x = args, i = 0; is_pair(x); x = cdr(x), i++)
                            vector_element(vec, i) = car(x);
                    }
                    return(vec);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x313be
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x2f202
testq %r15, %r15
jle 0x62b63
xorl %ecx, %ecx
cmpb $0x1, (%rbx)
jne 0x62b63
movq 0x8(%rbx), %rdx
movq 0x10(%rax), %rsi
movq %rdx, (%rsi,%rcx)
movq 0x10(%rbx), %rbx
addq $0x8, %rcx
jmp 0x62b48
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_subvector_position
static s7_pointer g_subvector_position(s7_scheme *sc, s7_pointer args)
                {
#define H_subvector_position "(subvector-position obj) returns obj's offset"
#define Q_subvector_position s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_subvector_symbol)

                    s7_pointer sv;
                    sv = car(args);
                    if (s7_is_subvector(sv))
                        return(make_integer(sc, (s7_int)(vector_elements(sv) - vector_elements(subvector_vector(sv)))));

                    return(method_or_bust_one_arg(sc, sv, sc->subvector_position_symbol, args, T_VECTOR));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leaq 0xb6cd9(%rip), %rdx     # 0x119c20
cmpb $0x1, (%rax,%rdx)
jne 0x62f53
testb $0x20, 0x3(%rsi)
jne 0x62f6d
movq 0x1598(%rbx), %rdx
pushq $0x15
popq %r8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77745
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rcx
leaq 0x20(%rcx), %rdx
addq $0x18, %rax
testq %rcx, %rcx
cmovneq %rdx, %rax
movq (%rax), %rax
subq 0x10(%rax), %r14
sarq $0x3, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x62fa9
leaq 0xb29ad(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x62fe2
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x62fc8
movq %rbx, %rdi
callq 0x9c27
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_O2/BernardTatin[P]s7sh/s7.c
// Function: g_subvector_vector
static s7_pointer g_subvector_vector(s7_scheme *sc, s7_pointer args)
                {
#define H_subvector_vector "(subvector-vector obj) returns the vector underlying the subvector obj"
#define Q_subvector_vector s7_make_signature(sc, 2, sc->is_vector_symbol, sc->is_subvector_symbol)

                    if (s7_is_subvector(car(args)))
                        return(subvector_vector(car(args)));
                    return(method_or_bust_one_arg(sc, car(args), sc->subvector_vector_symbol, args, T_VECTOR));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leaq 0xb6c25(%rip), %rdx     # 0x119c20
cmpb $0x1, (%rax,%rdx)
jne 0x63007
testb $0x20, 0x3(%rsi)
jne 0x63017
movq 0x15a0(%rdi), %rdx
pushq $0x15
popq %r8
jmp 0x77745
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rcx
leaq 0x20(%rcx), %rdx
addq $0x18, %rax
testq %rcx, %rcx
cmovneq %rdx, %rax
movq (%rax), %rax
retq