LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x75c46
movzbl (%r15), %eax
leaq 0xdd47b(%rip), %rcx     # 0x1530a0
cmpb $0x1, (%rax,%rcx)
jne 0x75ce0
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x39ea6
movq 0x110(%rbx), %r13
cmpq %r13, %r14
je 0x75d4a
movq 0x1340(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x75c7c
movq %rbx, %rdi
callq 0xa550
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 0xdf91d(%rip), %r8      # 0x1555e0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe659
leaq 0xd4c89(%rip), %rcx     # 0x14a970
cmpb $0x0, (%rax,%rcx)
je 0x75d04
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfdf10
movq %r14, %r12
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x40412
testb %al, %al
jne 0x75d51
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x75d4a
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x40412
testb %al, %al
jne 0x75d51
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x75d4a
movq 0x10(%r14), %r14
cmpq %r12, %r14
jne 0x75d07
movq 0x120(%rbx), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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 0x766de
movq 0x10(%rcx), %r14
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd64d1
movq 0x10(%r14), %r14
cmpq 0x110(%rbx), %r14
je 0x76703
cmpb $0x1, (%rax)
je 0x766a8
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd5b09
movq 0x1258(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe42d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x769e4
movq 0x8(%rsi), %rax
testq %rax, %rax
js 0x76978
cmpq 0x2b0(%rdi), %rax
jle 0x769fd
testq %rax, %rax
movq 0x1308(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xcffcb(%rip), %rcx     # 0x146958
leaq 0xd40b4(%rip), %rdx     # 0x14aa48
leaq 0xd40a5(%rip), %r8      # 0x14aa40
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 0x38dfa
movq %rbx, %rax
popq %rbx
retq
movq 0x1308(%rdi), %rdx
movl $0xb, %r8d
movl $0x1, %r9d
popq %rbx
jmp 0xe42d
testq %rax, %rax
je 0x76a23
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 0x3a029
movq 0x110(%rdi), %rbx
jmp 0x769df
// File: /workspace/github_c_makefile_star2_O3/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 0x79965
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39d6f
testb %al, %al
je 0x7997a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a0f6
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 0x3a6f0
movq 0x1770(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x799a0
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xd9253(%rip), %r8      # 0x152c18
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfa261
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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 0xd121b(%rip), %rdx     # 0x14ac20
cmpb $0x0, (%rax,%rdx)
je 0x79a25
movq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x79a41
leaq 0xccf31(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x79a7a
movq 0x1778(%rbx), %rdx
movq %rbx, %rdi
movl $0x15, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95069
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x79a60
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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 0xd0f82(%rip), %rdx     # 0x14ac20
cmpb $0x0, (%rax,%rdx)
je 0x79cad
movq 0x10(%rcx), %rdx
jmp 0xd5793
movq 0x1660(%rdi), %rdx
movl $0x15, %r8d
movl $0x1, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/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 0x7a11d
xorl %r12d, %r12d
movq %rbx, %rax
incq %r12
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x7a10f
jmp 0x7a120
xorl %r12d, %r12d
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0x7a13f
movq %r15, %rdi
callq 0xa550
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 0x7a170
movq %r15, %rdi
callq 0x9357
jmp 0x7a1d6
movq 0x838(%r15), %rax
testq %rax, %rax
jne 0x7a1bb
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, 0x838(%r15)
movq %rax, %rcx
addq $0x28, %rcx
movl $0xff, %edx
movq %rcx, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
addq $0x28, %rcx
decl %edx
jne 0x7a199
movq $0x0, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
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 -0x1dfa7(%rip), %rax    # 0x5c249
movq %rax, 0x20(%r14)
leaq -0x1dfa9(%rip), %rax    # 0x5c252
movq %rax, 0x28(%r14)
movq 0x740(%r15), %r15
movq (%r15), %rax
movq 0x10(%r15), %rsi
cmpq 0x8(%r15), %rsi
jne 0x7a22e
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r15)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r15)
movq 0x10(%r15), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r15)
movq %r14, (%rax,%rsi,8)
testq %r12, %r12
jle 0x7a25f
cmpb $0x1, (%rbx)
jne 0x7a25f
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 0x7a246
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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 0xd04b4(%rip), %rdx     # 0x14ac20
cmpb $0x1, (%rax,%rdx)
jne 0x7a778
testb $0x20, 0x3(%rsi)
jne 0x7a794
movq 0x1598(%rbx), %rdx
movq %rbx, %rdi
movl $0x15, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95069
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 0x7a7d0
leaq 0xcc186(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x7a809
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7a7ef
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_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 0xd03fe(%rip), %rdx     # 0x14ac20
cmpb $0x1, (%rax,%rdx)
jne 0x7a82e
testb $0x20, 0x3(%rsi)
jne 0x7a840
movq 0x15a0(%rdi), %rdx
movl $0x15, %r8d
jmp 0x95069
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_O3/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 0x7bb87
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3cd0e
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 0x404ff
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x7bbad
movq %r14, %rdi
callq 0xa550
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 0xe42d
// File: /workspace/github_c_makefile_star2_O3/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 0x7bc4d
movq 0x8(%r15), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xeab0
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 0x404ff
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x7bc73
movq %r14, %rdi
callq 0xa550
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 0xe42d
// File: /workspace/github_c_makefile_star2_O3/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 0x7bfa4
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 0x7c00b
cmpq 0x120(%rbx), %r15
je 0x7bfd0
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd5b09
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 0xe42d
movq 0x1900(%rbx), %r15
movq 0xd70ba(%rip), %rax     # 0x153098
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 0x38dfa
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table_set
static s7_pointer g_hash_table_set(s7_scheme *sc, s7_pointer args)
                {
#define H_hash_table_set "(hash-table-set! table key value) sets the value associated with key in the hash table to value"
#define Q_hash_table_set s7_make_signature(sc, 4, sc->T, sc->is_hash_table_symbol, sc->T, sc->T)

                    s7_pointer table;
                    table = car(args);
                    if (!is_mutable_hash_table(table))
                        return(mutable_method_or_bust(sc, table, sc->hash_table_set_symbol, args, T_HASH_TABLE, 1));
                    return(s7_hash_table_set(sc, table, cadr(args), caddr(args)));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movl $0x10000ff, %eax        # imm = 0x10000FF
andl (%rsi), %eax
cmpl $0x1b, %eax
jne 0x7c042
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
jmp 0x36924
movq 0xf70(%rdi), %rdx
movl $0x1b, %r8d
jmp 0xe7180
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table_entries
static s7_pointer g_hash_table_entries(s7_scheme *sc, s7_pointer args)
                {
#define H_hash_table_entries "(hash-table-entries obj) returns the number of entries in the hash-table obj"
#define Q_hash_table_entries s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_hash_table_symbol)

                    if (!is_hash_table(car(args)))
                        return(method_or_bust_one_arg(sc, car(args), sc->hash_table_entries_symbol, args, T_HASH_TABLE));
                    return(make_integer(sc, hash_table_entries(car(args))));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x1b, (%rsi)
jne 0x7c085
movq 0x28(%rsi), %rax
movq 0x18(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x7c0a1
leaq 0xca8d1(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x7c0da
movq 0xf60(%rbx), %rdx
movq %rbx, %rdi
movl $0x1b, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95069
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7c0c0
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_eval
static s7_pointer g_eval(s7_scheme *sc, s7_pointer args)
                {
#define H_eval "(eval code (env (curlet))) evaluates code in the environment env. 'env' \
                    defaults to the curlet; to evaluate something in the top-level environment instead, \
                    pass (rootlet):\n\
                    \n\
                    (define x 32) \n\
                    (let ((x 3))\n\
                     (eval 'x (rootlet)))\n\
                    \n\
                    returns 32"
#define Q_eval s7_make_signature(sc, 3, sc->values_symbol, sc->T, sc->is_let_symbol)

                    if (is_not_null(cdr(args)))
                    {
                        s7_pointer e;
                        e = cadr(args);
                        if (!is_let(e))
                            return(wrong_type_argument_with_type(sc, sc->eval_symbol, 2, e, a_let_string));
                        if (e == sc->rootlet)
                            sc->envir = sc->nil;
                        else sc->envir = e;
                    }
                    sc->code = car(args);

                    if ((sc->safety > NO_SAFETY) &&
                            (is_pair(sc->code)))
                    {
                        check_heap_size(sc, 8192);
                        sc->code = copy_body(sc, sc->code);
                    }
                    else
                    {
                        if (is_optimized(sc->code))
                            clear_all_optimizations(sc, sc->code);
                    }

                    if (s7_stack_top(sc) < 12)
                        push_stack_op(sc, OP_BARRIER);
                    push_stack(sc, OP_EVAL, sc->args, sc->code);

                    return(sc->nil);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
movq 0x110(%rdi), %rax
cmpq %rax, %rcx
je 0x7cf19
movq 0x8(%rcx), %rcx
cmpb $0x1c, (%rcx)
jne 0x7cfb5
cmpq 0x150(%rbx), %rcx
cmovneq %rcx, %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsi), %rdi
movq %rdi, (%rbx)
cmpq $0x0, 0x6a0(%rbx)
jle 0x7cf4c
cmpb $0x1, (%rdi)
jne 0x7cf4c
movl $0x2000, %esi           # imm = 0x2000
movq %rbx, %rdi
callq 0x3bbd4
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x9a2e1
movq %rax, (%rbx)
jmp 0x7cf58
cmpw $0x801, (%rdi)          # imm = 0x801
jne 0x7cf58
callq 0xcc395
movq 0x50(%rbx), %rax
movq %rax, %rcx
subq 0x48(%rbx), %rcx
cmpq $0x5f, %rcx
jg 0x7cf7d
movq $0x203, 0x18(%rax)      # imm = 0x203
movq 0x50(%rbx), %rax
addq $0x20, %rax
movq %rax, 0x50(%rbx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x191, 0x18(%rax)      # imm = 0x191
addq $0x20, 0x50(%rbx)
movq 0x110(%rbx), %rax
popq %rbx
retq
movq 0xeb8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xc9999(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0xcd983(%rip), %r9      # 0x14a958
movq %rbx, %rdi
popq %rbx
jmp 0xa4e4
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_eval_string
static s7_pointer g_eval_string(s7_scheme *sc, s7_pointer args)
    {
#define H_eval_string "(eval-string str (env (curlet))) returns the result of evaluating the string str as Scheme code"
#define Q_eval_string s7_make_signature(sc, 3, sc->values_symbol, sc->is_string_symbol, sc->is_let_symbol)
        s7_pointer port, str;

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

        if (is_not_null(cdr(args)))
        {
            s7_pointer e;
            e = cadr(args);
            if (!is_let(e))
                return(wrong_type_argument_with_type(sc, sc->eval_string_symbol, 2, e, a_let_string));
            if (e == sc->rootlet)
                sc->envir = sc->nil;
            else sc->envir = e;
        }

        port = open_and_protect_input_string(sc, str);
        push_input_port(sc, port);

        sc->temp3 = sc->args;
        push_stack(sc, OP_EVAL_STRING, args, sc->code);
        push_stack_op_let(sc, OP_READ_INTERNAL);

        return(sc->F);  /* I think this means that sc->value defaults to #f in op_eval_string below, so (eval-string "") mimics (eval) -> #f */
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x7d042
movq 0x10(%r14), %rcx
movq 0x110(%rbx), %rax
cmpq %rax, %rcx
je 0x7d01e
movq 0x8(%rcx), %rcx
cmpb $0x1c, (%rcx)
jne 0x7d10e
cmpq 0x150(%rbx), %rcx
cmovneq %rcx, %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0xfa2bb
movq %rax, %r15
movl 0x180(%rbx), %esi
movl 0x184(%rbx), %ecx
cmpl %esi, %ecx
jae 0x7d065
movq 0x178(%rbx), %rax
jmp 0x7d08a
movq 0xeb0(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
popq %rbx
popq %r14
popq %r15
jmp 0xe42d
addl %esi, %esi
movl %esi, 0x180(%rbx)
movq 0x178(%rbx), %rdi
shlq $0x3, %rsi
callq 0x8510
movq %rax, 0x178(%rbx)
movl 0x184(%rbx), %ecx
movq 0x170(%rbx), %rdx
leal 0x1(%rcx), %esi
movl %esi, 0x184(%rbx)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq %r15, 0x170(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x508(%rbx)
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq %r14, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x20f, 0x18(%rax)      # imm = 0x20F
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x28(%rcx)
movq 0x50(%rbx), %rax
movq $0x190, 0x18(%rax)      # imm = 0x190
addq $0x20, 0x50(%rbx)
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xeb0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xc9840(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0xcd82a(%rip), %r9      # 0x14a958
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa4e4
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_error
static s7_pointer g_error(s7_scheme *sc, s7_pointer args)
                {
#define H_error "(error type ...) signals an error.  The 'type' can be used with catch to trap \
                    particular errors.  If the error is not caught, s7 treats the second argument as a format control string, \
                    and applies it to the rest of the arguments."
#define Q_error s7_make_circular_signature(sc, 1, 2, sc->values_symbol, sc->T)

                    if (is_not_null(args))
                    {
                        if (is_string(car(args)))                     /* CL-style error? -- use tag = 'no-catch */
                        {
                            s7_error(sc, sc->no_catch_symbol, args);  /* this can have trailing args (implicit format) */
                            return(sc->unspecified);
                        }
                        return(s7_error(sc, car(args), cdr(args)));
                    }
                    return(s7_error(sc, sc->nil, sc->nil));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x110(%rdi), %rbx
cmpq %rsi, %rbx
je 0x7e989
movq %rsi, %rdx
movq 0x8(%rsi), %rbx
cmpb $0x13, (%rbx)
jne 0x7e994
movq 0x1928(%r14), %rsi
movq %r14, %rdi
callq 0x38dfa
movq 0x130(%r14), %rbx
jmp 0x7e9a3
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
jmp 0x7e99e
movq 0x10(%rdx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_apply_values
static s7_pointer g_apply_values(s7_scheme *sc, s7_pointer args)
                {
#define H_apply_values "(apply-values var) applies values to var.  This is an internal function."
#define Q_apply_values s7_make_signature(sc, 2, sc->T, sc->is_list_symbol)
                    s7_pointer x;
                    /* apply-values takes 1 arg: ,@a -> (apply-values a) */
                    if (is_null(args))
                        return(sc->no_value);

                    x = car(args);
                    if (is_null(x))
                        return(sc->no_value);

                    if (!s7_is_proper_list(sc, x))
                        return(apply_list_error(sc, args));

                    return(g_values(sc, x));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x110(%rdi), %rax
cmpq %rsi, %rax
je 0x7ebc8
movq %rsi, %r14
movq 0x8(%rsi), %r15
cmpq %rax, %r15
je 0x7ebc8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39d6f
movq %rbx, %rdi
testb %al, %al
je 0x7ebd5
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x459be
movq 0x138(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xccc97
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_help
static s7_pointer g_help(s7_scheme *sc, s7_pointer args)
                {
#define H_help "(help obj) returns obj's documentation"
#define Q_help s7_make_signature(sc, 2, s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_boolean_symbol), sc->T)
                    const char *doc;

                    check_method(sc, car(args), sc->help_symbol, args);
                    doc = s7_help(sc, car(args));
                    if (!doc)
                        return(sc->F);
                    return(s7_make_string(sc, doc));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r12
testb $0x40, 0x3(%r12)
je 0x7f158
cmpb $0x1, 0x24c(%rbx)
jne 0x7f158
movq %rsi, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a63
movq 0xf80(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x7f158
cmpb $0x1, (%r15)
jne 0x7f197
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x7f0af
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x7f13d
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x7f10e
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x7f0e4
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x7f19e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3e92a
testq %rax, %rax
je 0x7f181
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe9af
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_dilambda
static s7_pointer g_dilambda(s7_scheme *sc, s7_pointer args)
                {
#define H_dilambda "(dilambda getter setter) sets getter's setter to be setter."
#define Q_dilambda s7_make_signature(sc, 3, sc->is_procedure_symbol, sc->is_procedure_symbol, sc->is_procedure_symbol)
                    s7_pointer getter, setter;

                    getter = car(args);
                    if (!is_any_procedure(getter))
                        return(wrong_type_argument_with_type(sc, sc->dilambda_symbol, 1, getter, wrap_string(sc, "a procedure or a macro", 22)));

                    setter = cadr(args);
                    if (!is_any_procedure(setter))
                        return(wrong_type_argument_with_type(sc, sc->dilambda_symbol, 2, setter, wrap_string(sc, "a procedure or a macro", 22)));

                    s7_set_setter(sc, getter, setter);
                    return(getter);
                }

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rbx
cmpb $0x27, (%rbx)
jbe 0x7f75d
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rcx
cmpb $0x27, (%rcx)
jbe 0x7f7ac
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x3fddc
movq %rbx, %rax
popq %rbx
retq
movq 0xe78(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xc71e9(%rip), %rdx     # 0x146958
movq 0x140(%rdi), %r8
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %r9
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x9c72e(%rip), %rax     # 0x11bec9
movq %rax, 0x10(%r9)
movq $0x16, 0x8(%r9)
movq %rbx, %rcx
jmp 0x7f7f7
movq 0xe78(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xc71a2(%rip), %rdx     # 0x146960
movq 0x140(%rdi), %r8
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r10
movq (%rax,%r10,8), %r9
leal 0x1(%r10), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x9c6de(%rip), %rax     # 0x11bec9
movq %rax, 0x10(%r9)
movq $0x16, 0x8(%r9)
popq %rbx
jmp 0xa4e4
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_is_aritable
static s7_pointer g_is_aritable(s7_scheme *sc, s7_pointer args)
                {
#define H_is_aritable "(aritable? obj num-args) returns #t if 'obj can be applied to 'num-args arguments."
#define Q_is_aritable s7_make_signature(sc, 3, sc->is_boolean_symbol, sc->T, sc->is_integer_symbol)

                    s7_pointer n;
                    s7_int num;

                    n = cadr(args);
                    if (!s7_is_integer(n)) /* remember gmp case! */
                        return(method_or_bust(sc, n, sc->is_aritable_symbol, args, T_INTEGER, 2));

                    num = s7_integer(n);
                    if (num < 0)
                        return(out_of_range(sc, sc->is_aritable_symbol, small_int(2), n, its_negative_string));
                    if (num > MAX_ARITY) num = MAX_ARITY;

                    return(make_boolean(sc, s7_is_aritable(sc, car(args), num)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0x7f84d
movq 0x8(%rsi), %rax
testq %rax, %rax
js 0x7f86f
movl $0x20000000, %edx       # imm = 0x20000000
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq 0x8(%rcx), %rsi
movq %rbx, %rdi
callq 0x3f86f
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %r14
jmp 0x7f8c8
movq 0xfd0(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe42d
movq 0xfd0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc70df(%rip), %rcx     # 0x146960
movq 0xcb1c0(%rip), %rdx     # 0x14aa48
movq 0x1ee8(%rbx), %rdi
movq 0x10(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x10(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38dfa
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_optimize
static s7_pointer g_optimize(s7_scheme *sc, s7_pointer args)
                {
                    s7_function f;
                    s7_pointer code;
                    code = car(args);
                    f = s7_optimize(sc, code);
                    if (f)
                        return(f(sc, car(code)));
                    return(sc->undefined);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x4588d
testq %rax, %rax
je 0x7fbd9
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0x128(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_c_object_set
static s7_pointer g_c_object_set(s7_scheme *sc, s7_pointer args) /* called in c_object_set_function */
                {
                    s7_pointer obj;
                    obj = car(args);
                    if (!is_c_object(obj))
                        return(simple_wrong_type_argument(sc, make_symbol(sc, "c-object-set!"), obj, T_C_OBJECT));
                    return((*(c_object_set(sc, obj)))(sc, args));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x14, (%r14)
jne 0x7fc18
movq 0x8d8(%rbx), %rax
movq 0x8(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x9bc16(%rip), %rsi     # 0x11b835
movq %rbx, %rdi
callq 0x9afc
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xcaec7(%rip), %r8      # 0x14ab00
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_tree_count
static s7_pointer g_tree_count(s7_scheme *sc, s7_pointer args)
                {
#define H_tree_count "(tree-count obj tree max-count) returns how many times obj is in tree (using eq?), stopping at max-count (if specified)"
#define Q_tree_count s7_make_signature(sc, 4, sc->is_integer_symbol, sc->T, sc->T, sc->is_integer_symbol)
                    s7_pointer obj, tree, count;

                    obj = car(args);
                    tree = cadr(args);
                    if (!is_pair(tree))
                    {
                        if ((is_pair(cddr(args))) &&
                                (!is_t_integer(caddr(args))))
                            return(simple_wrong_type_argument(sc, sc->tree_count_symbol, caddr(args), T_INTEGER));
                        return((obj == tree) ? small_int(1) : small_int(0));
                    }
                    if ((sc->safety > NO_SAFETY) &&
                            (tree_is_cyclic(sc, tree)))
                        s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-count: tree is cyclic", 26));
                    if (is_null(cddr(args)))
                        return(s7_make_integer(sc, tree_count(sc, obj, tree, 0)));
                    count = caddr(args);
                    if (!s7_is_integer(count))
                        return(simple_wrong_type_argument(sc, sc->tree_count_symbol, count, T_INTEGER));
                    return(s7_make_integer(sc, tree_count_at_least(sc, obj, tree, 0, s7_integer(count))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
cmpb $0x1, (%r15)
jne 0x7fd54
movq %rsi, %r12
cmpq $0x0, 0x6a0(%rbx)
jle 0x7fd1f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38d93
testb %al, %al
je 0x7fd1f
movq 0x1940(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rdx
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0x9c204(%rip), %rax     # 0x11bf0f
movq %rax, 0x10(%rdx)
movq $0x1a, 0x8(%rdx)
movq %rbx, %rdi
callq 0x38dfa
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpq 0x110(%rbx), %rax
je 0x7fdb6
movq 0x8(%rax), %rdx
cmpb $0xb, (%rdx)
jne 0x7fd8a
movq 0x8(%rdx), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xffe7c
jmp 0x7fdc6
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x7fd66
movq 0x8(%rax), %rdx
cmpb $0xb, (%rdx)
jne 0x7fd8a
cmpq %r15, %r14
leaq 0xc6be8(%rip), %rax     # 0x146958
leaq 0xc6bd9(%rip), %rcx     # 0x146950
cmoveq %rax, %rcx
movq (%rcx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x15f8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xcad15(%rip), %r8      # 0x14aab8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xed2a
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xa9428
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd27e
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_features_set
static s7_pointer g_features_set(s7_scheme *sc, s7_pointer args) /* *features* setter */
    {
        s7_pointer nf;
        nf = cadr(args);
        if (is_null(nf))
            return(sc->nil);
        if (is_pair(nf))
        {
            s7_pointer p;
            if (s7_list_length(sc, nf) <= 0)
                return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *features* to ~S", 26), nf)));
            for (p = nf; is_pair(p); p = cdr(p))
                if (!is_symbol(car(p)))
                    return(simple_wrong_type_argument(sc, sc->features_symbol, car(p), T_SYMBOL));
            return(nf);
        }
        return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *features* to ~S", 26), nf)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
movq 0x110(%rdi), %r15
cmpq %r15, %r14
je 0x7feab
movq %rdi, %rbx
cmpb $0x1, (%r14)
jne 0x7fe48
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39d0d
testq %rax, %rax
jle 0x7fe48
movq %r14, %rax
movq 0x8(%rax), %rdx
cmpb $0xa, (%rdx)
jne 0x7feb4
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x7fe31
movq %r14, %r15
jmp 0x7feab
movq 0xea8(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x9c0b7(%rip), %rcx     # 0x11bf2a
movq %rcx, 0x10(%rax)
movq $0x1a, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38dfa
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xee0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xcabe3(%rip), %r8      # 0x14aab0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_load_path_set
static s7_pointer g_load_path_set(s7_scheme *sc, s7_pointer args)
    {
        /* new value must be either () or a proper list of strings */
        if (is_null(cadr(args))) return(cadr(args));
        if (is_pair(cadr(args)))
        {
            s7_pointer x;
            for (x = cadr(args); is_pair(x); x = cdr(x))
                if (!is_string(car(x)))
                    return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *load-path* to ~S", 27), cadr(args))));
            if (is_null(x))
                return(cadr(args));
        }
        return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *load-path* to ~S", 27), cadr(args))));
    }

// Assembly:
pushq %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rbx
movq 0x110(%rdi), %rax
cmpq %rax, %rbx
je 0x7ff7a
cmpb $0x1, (%rbx)
jne 0x7ff12
movq %rbx, %rcx
movq 0x8(%rcx), %rdx
cmpb $0x13, (%rdx)
jne 0x7ff12
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0x7fefb
cmpq %rax, %rcx
je 0x7ff7a
movq 0xea8(%rdi), %rbx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x9c008(%rip), %rcx     # 0x11bf45
movq %rcx, 0x10(%rax)
movq $0x1b, 0x8(%rax)
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq