LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7a6c8
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a6e0
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a6fb
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a716
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcb0(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xcb0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2e77(%rip), %r8      # 0x15d570
jmp 0x7a72f
movq 0xcb0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2e6c(%rip), %r8      # 0x15d580
jmp 0x7a72f
movq 0xcb0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2e91(%rip), %r8      # 0x15d5c0
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7a760
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a778
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a793
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a7ae
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xc98(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xc98(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2de7(%rip), %r8      # 0x15d578
jmp 0x7a7c7
movq 0xc98(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2dec(%rip), %r8      # 0x15d598
jmp 0x7a7c7
movq 0xc98(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2df1(%rip), %r8      # 0x15d5b8
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7a7f8
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a810
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a82b
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a846
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcd0(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xcd0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2d4f(%rip), %r8      # 0x15d578
jmp 0x7a85f
movq 0xcd0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2d54(%rip), %r8      # 0x15d598
jmp 0x7a85f
movq 0xcd0(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2d79(%rip), %r8      # 0x15d5d8
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7a890
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a8a8
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a8c3
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a8de
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcb8(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xcb8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2cb7(%rip), %r8      # 0x15d578
jmp 0x7a8f7
movq 0xcb8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2cac(%rip), %r8      # 0x15d588
jmp 0x7a8f7
movq 0xcb8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2cd1(%rip), %r8      # 0x15d5c8
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7a928
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a940
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a95b
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a976
movq 0x8(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xcc8(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xcc8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2c17(%rip), %r8      # 0x15d570
jmp 0x7a98f
movq 0xcc8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2c1c(%rip), %r8      # 0x15d590
jmp 0x7a98f
movq 0xcc8(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2c41(%rip), %r8      # 0x15d5d0
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7a9c0
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7a9d8
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7a9f3
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7aa0e
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd30(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd30(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2b7f(%rip), %r8      # 0x15d570
jmp 0x7aa27
movq 0xd30(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2b74(%rip), %r8      # 0x15d580
jmp 0x7aa27
movq 0xd30(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2b79(%rip), %r8      # 0x15d5a0
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7aa58
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7aa70
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7aa8b
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7aaa6
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd38(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd38(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2aef(%rip), %r8      # 0x15d578
jmp 0x7aabf
movq 0xd38(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2ae4(%rip), %r8      # 0x15d588
jmp 0x7aabf
movq 0xd38(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2ae9(%rip), %r8      # 0x15d5a8
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7aaf0
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7ab08
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ab23
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ab3e
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd48(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd48(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2a4f(%rip), %r8      # 0x15d570
jmp 0x7ab57
movq 0xd48(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2a54(%rip), %r8      # 0x15d590
jmp 0x7ab57
movq 0xd48(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2a59(%rip), %r8      # 0x15d5b0
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7ab88
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7aba0
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7abbb
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7abd6
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd68(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd68(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe29b7(%rip), %r8      # 0x15d570
jmp 0x7abef
movq 0xd68(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe29ac(%rip), %r8      # 0x15d580
jmp 0x7abef
movq 0xd68(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe29d1(%rip), %r8      # 0x15d5c0
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7ac20
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7ac38
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ac53
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ac6e
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd50(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd50(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2927(%rip), %r8      # 0x15d578
jmp 0x7ac87
movq 0xd50(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe292c(%rip), %r8      # 0x15d598
jmp 0x7ac87
movq 0xd50(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2931(%rip), %r8      # 0x15d5b8
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7acb8
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7acd0
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7aceb
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ad06
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd88(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd88(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe288f(%rip), %r8      # 0x15d578
jmp 0x7ad1f
movq 0xd88(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2894(%rip), %r8      # 0x15d598
jmp 0x7ad1f
movq 0xd88(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe28b9(%rip), %r8      # 0x15d5d8
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7ad50
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7ad68
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ad83
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ad9e
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd70(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd70(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe27f7(%rip), %r8      # 0x15d578
jmp 0x7adb7
movq 0xd70(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe27ec(%rip), %r8      # 0x15d588
jmp 0x7adb7
movq 0xd70(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2811(%rip), %r8      # 0x15d5c8
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7ade8
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x7ae00
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ae1b
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x7ae36
movq 0x10(%rcx), %rax
retq
movq %rsi, %rcx
movq 0xd80(%rdi), %rdx
movq %rax, %rsi
movl $0x1, %r8d
jmp 0x9b739
movq 0xd80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2757(%rip), %r8      # 0x15d570
jmp 0x7ae4f
movq 0xd80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe275c(%rip), %r8      # 0x15d590
jmp 0x7ae4f
movq 0xd80(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x140(%rdi), %rcx
movq 0xe2781(%rip), %r8      # 0x15d5d0
movq %rax, %rdx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x7aeb5
movzbl (%r15), %eax
leaq 0xe020c(%rip), %rcx     # 0x15b0a0
cmpb $0x0, (%rax,%rcx)
je 0x7af4f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3c342
movq 0x110(%rbx), %r13
cmpq %r13, %r14
je 0x7afa9
movq 0xc00(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7aee4
movq %rbx, %rdi
callq 0xb389
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 0xe26be(%rip), %r8      # 0x15d5f0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3da
movq %r14, %r13
movq 0x8(%r13), %r12
cmpb $0x1, (%r12)
jne 0x7af6e
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x42c67
testb %al, %al
jne 0x7afb0
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
jne 0x7afa9
movq 0x8(%r13), %r12
cmpb $0x1, (%r12)
jne 0x7af95
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x42c67
testb %al, %al
jne 0x7afb0
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
jne 0x7afa9
movq 0x10(%r14), %r14
cmpq %r13, %r14
jne 0x7af52
movq 0x120(%rbx), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7b73e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3c432
movq 0x110(%rbx), %r13
cmpq %r13, %r14
je 0x7b7d8
movq 0x1338(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7b76d
movq %rbx, %rdi
callq 0xb389
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 0xe1e25(%rip), %r8      # 0x15d5e0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3da
movq 0x120(%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7b833
movzbl (%r15), %eax
leaq 0xdf88e(%rip), %rcx     # 0x15b0a0
cmpb $0x1, (%rax,%rcx)
jne 0x7b8cd
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3c432
movq 0x110(%rbx), %r13
cmpq %r13, %r14
je 0x7b937
movq 0x1340(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7b862
movq %rbx, %rdi
callq 0xb389
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 0xe1d30(%rip), %r8      # 0x15d5e0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3da
leaq 0xd709c(%rip), %rcx     # 0x152970
cmpb $0x0, (%rax,%rcx)
je 0x7b8f1
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x107157
movq %r14, %r12
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x42c67
testb %al, %al
jne 0x7b93e
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x7b937
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x42c67
testb %al, %al
jne 0x7b93e
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x7b937
movq 0x10(%r14), %r14
cmpq %r12, %r14
jne 0x7b8f4
movq 0x120(%rbx), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7c36a
movq 0x10(%rcx), %r14
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xded9d
movq 0x10(%r14), %r14
cmpq 0x110(%rbx), %r14
je 0x7c38f
cmpb $0x1, (%rax)
je 0x7c334
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xde3f2
movq 0x1258(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf1ae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0x7c670
movq 0x8(%rsi), %rax
testq %rax, %rax
js 0x7c604
cmpq 0x2b0(%rdi), %rax
jle 0x7c689
testq %rax, %rax
movq 0x1308(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xd233f(%rip), %rcx     # 0x14e958
leaq 0xd6428(%rip), %rdx     # 0x152a48
leaq 0xd6419(%rip), %r8      # 0x152a40
cmovsq %rdx, %r8
movq (%r8), %rdx
movq 0x1ee8(%rdi), %r8
movq 0x10(%r8), %r8
movq %rax, 0x8(%r8)
movq 0x10(%r8), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
popq %rbx
retq
movq 0x1308(%rdi), %rdx
movl $0xb, %r8d
movl $0x1, %r9d
popq %rbx
jmp 0xf1ae
testq %rax, %rax
je 0x7c6af
movq 0x10(%rcx), %rcx
leaq 0x8(%rcx), %rdx
leaq 0x120(%rdi), %rsi
cmpb $0x1, (%rcx)
cmoveq %rdx, %rsi
movq (%rsi), %rdx
movl %eax, %esi
popq %rbx
jmp 0x3c5b5
movq 0x110(%rdi), %rbx
jmp 0x7c66b
// File: /workspace/github_c_makefile_star2_O1/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 0x7f9b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c2fb
testb %al, %al
je 0x7f9c9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x801ce
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 0x3cc80
movq 0x1770(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7f9e8
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xdb204(%rip), %r8      # 0x15ac18
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x103001
// File: /workspace/github_c_makefile_star2_O1/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 0xd31cc(%rip), %rdx     # 0x152c20
cmpb $0x0, (%rax,%rdx)
je 0x7fa74
movq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x7fa90
leaq 0xceee2(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x7fac9
movq 0x1778(%rbx), %rdx
movq %rbx, %rdi
movl $0x15, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b739
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7faa8
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_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 0xd2f52(%rip), %rdx     # 0x152c20
cmpb $0x0, (%rax,%rdx)
je 0x7fcdd
movq 0x10(%rcx), %rdx
jmp 0xddf3e
movq 0x1660(%rdi), %rdx
movl $0x15, %r8d
movl $0x1, %r9d
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x1, (%rsi)
jne 0x801f5
xorl %r12d, %r12d
movq %rbx, %rax
incq %r12
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x801e7
jmp 0x801f8
xorl %r12d, %r12d
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0x80210
movq %r15, %rdi
callq 0xb389
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %r14
movq $0x200015, (%r14)       # imm = 0x200015
movq %r12, 0x8(%r14)
leaq (,%r12,8), %rsi
testq %rsi, %rsi
jle 0x80248
movq %r15, %rdi
callq 0xa305
jmp 0x802b0
cmpq $0x0, 0x838(%r15)
jne 0x8028e
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r15)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x8026c
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r15), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r15)
movl $0x0, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
movq $0x0, 0x20(%rax)
leaq -0x1efa5(%rip), %rax    # 0x61325
movq %rax, 0x20(%r14)
leaq -0x1efa7(%rip), %rax    # 0x6132e
movq %rax, 0x28(%r14)
movq 0x740(%r15), %r15
movq 0x8(%r15), %rsi
cmpq %rsi, 0x10(%r15)
jne 0x80301
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r15)
movq (%r15), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r15)
movq (%r15), %rax
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
movq %r14, (%rax,%rcx,8)
testq %r12, %r12
jle 0x80339
cmpb $0x1, (%rbx)
jne 0x80339
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq 0x10(%r14), %rdx
movq %rcx, (%rdx,%rax)
movq 0x10(%rbx), %rbx
addq $0x8, %rax
cmpb $0x1, (%rbx)
je 0x80320
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_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 0xd2393(%rip), %rdx     # 0x152c20
cmpb $0x1, (%rax,%rdx)
jne 0x80899
testb $0x20, 0x3(%rsi)
jne 0x808b5
movq 0x1598(%rbx), %rdx
movq %rbx, %rdi
movl $0x15, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b739
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 0x808f1
leaq 0xce065(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x8092a
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x80909
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_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 0xd22dd(%rip), %rdx     # 0x152c20
cmpb $0x1, (%rax,%rdx)
jne 0x8094f
testb $0x20, 0x3(%rsi)
jne 0x80961
movq 0x15a0(%rdi), %rdx
movl $0x15, %r8d
jmp 0x9b739
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
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_string_to_byte_vector
static s7_pointer g_string_to_byte_vector(s7_scheme *sc, s7_pointer args)
                {
#define H_string_to_byte_vector "(string->byte-vector obj) turns a string into a byte-vector."
#define Q_string_to_byte_vector s7_make_signature(sc, 2, sc->is_byte_vector_symbol, sc->is_string_symbol)
                    s7_pointer str;
                    str = car(args);
                    if (!is_string(str))
                        return(method_or_bust(sc, str, sc->string_to_byte_vector_symbol, list_1(sc, str), T_STRING, 1));
                    return(s7_copy_1(sc, sc->string_to_byte_vector_symbol, set_plist_2(sc, str, make_simple_byte_vector(sc, string_length(str)))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rsi), %r15
cmpb $0x13, (%r15)
movq 0x15f0(%rdi), %rbx
jne 0x81d51
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3f2f5
movq 0x708(%r14), %rcx
movq %r15, 0x8(%rcx)
movq 0x710(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x708(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42d53
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x81d70
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r15, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_byte_vector_to_string
static s7_pointer g_byte_vector_to_string(s7_scheme *sc, s7_pointer args)
                {
#define H_byte_vector_to_string "(byte-vector->string obj) turns a byte-vector into a string."
#define Q_byte_vector_to_string s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_byte_vector_symbol)
                    s7_pointer v;
                    v = car(args);
                    if (!is_byte_vector(v))
                        return(method_or_bust(sc, v, sc->byte_vector_to_string_symbol, list_1(sc, v), T_BYTE_VECTOR, 1));
                    return(s7_copy_1(sc, sc->byte_vector_to_string_symbol, set_plist_2(sc, v, make_empty_string(sc, byte_vector_length(v), 0))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rsi), %r15
cmpb $0x18, (%r15)
movq 0xc40(%rdi), %rbx
jne 0x81e17
movq 0x8(%r15), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xf83b
movq 0x708(%r14), %rcx
movq %r15, 0x8(%rcx)
movq 0x710(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x708(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42d53
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x81e36
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r15, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x18, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table_ref
static s7_pointer g_hash_table_ref(s7_scheme *sc, s7_pointer args)
                {
#define H_hash_table_ref "(hash-table-ref table key) returns the value associated with key in the hash table"
#define Q_hash_table_ref s7_make_circular_signature(sc, 2, 3, sc->T, sc->is_hash_table_symbol, sc->T)

                    s7_pointer table, nt;
                    table = car(args);
                    if (!is_hash_table(table))
                        return(method_or_bust(sc, table, sc->hash_table_ref_symbol, args, T_HASH_TABLE, 1));
                    nt = s7_hash_table_ref(sc, table, cadr(args));
                    if (is_null(cddr(args)))
                        return(nt);
                    if (nt == sc->F) /* need the error here, not in implicit_index because table should be in the error message, not nt */
                        return(s7_error(sc, sc->wrong_number_of_args_symbol, set_elist_3(sc, too_many_arguments_string, table, args)));
                    return(implicit_index(sc, nt, cddr(args))); /* 9-Jan-19 */
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpb $0x1b, (%r12)
jne 0x82167
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq *0x18(%r12)
movq 0x20(%rax), %r15
movq 0x10(%r14), %rax
movq 0x10(%rax), %rdx
cmpq 0x110(%rbx), %rdx
je 0x821ce
cmpq 0x120(%rbx), %r15
je 0x82193
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xde3f2
movq 0xf68(%rbx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rcx
movl $0x1b, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf1ae
movq 0x1900(%rbx), %r15
movq 0xd8ef7(%rip), %rax     # 0x15b098
movq 0x6e8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %r12, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b366
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq