LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_float_vector
static s7_pointer g_float_vector(s7_scheme *sc, s7_pointer args)
                {
#define H_float_vector "(float-vector ...) returns an homogeneous float vector whose elements are the arguments"
#define Q_float_vector s7_make_circular_signature(sc, 1, 2, sc->is_float_vector_symbol, sc->is_real_symbol)

                    s7_int len;
                    s7_pointer vec;

                    len = safe_list_length(args);
                    vec = make_simple_float_vector(sc, len);
                    if (len > 0)
                    {
                        s7_int i;
                        s7_pointer x;
                        sc->w = vec;
                        for (x = args, i = 0; is_pair(x); x = cdr(x), i++)
                        {
                            s7_pointer p;
                            p = car(x);
                            if (is_t_real(p))
                                float_vector(vec, i) = real(p);
                            else
                            {
                                if (s7_is_real(p))                         /* bignum is ok here */
                                    float_vector(vec, i) = s7_real(p);
                                else
                                {
                                    sc->w = sc->nil;
                                    return(method_or_bust(sc, p, sc->float_vector_symbol, copy_list(sc, args), T_REAL, i + 1));
                                }
                            }
                        }
                        sc->w = sc->nil;
                    }
                    return(vec);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x313be
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fd63
movq %rax, %r12
testq %r15, %r15
jle 0x630c3
movq %r12, 0x4d8(%rbx)
xorl %r15d, %r15d
leaq 0xb693e(%rip), %rbp     # 0x1199b0
movq %r14, (%rsp)
cmpb $0x1, (%r14)
jne 0x630b5
movq 0x8(%r14), %r13
movzbl (%r13), %eax
cmpq $0xd, %rax
jne 0x63093
movsd 0x8(%r13), %xmm0
jmp 0x630a1
cmpb $0x1, (%rax,%rbp)
jne 0x630d5
movq %r13, %rdi
callq 0xc42a
movq 0x10(%r12), %rax
movsd %xmm0, (%rax,%r15,8)
movq 0x10(%r14), %r14
incq %r15
jmp 0x63076
movq 0x110(%rbx), %rax
movq %rax, 0x4d8(%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %rax
movq %rax, 0x4d8(%rbx)
movq 0xf00(%rbx), %r12
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x35492
incl %r15d
pushq $0xd
popq %r8
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
movl %r15d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_int_vector
static s7_pointer g_int_vector(s7_scheme *sc, s7_pointer args)
                {
#define H_int_vector "(int-vector ...) returns an homogeneous s7_int vector whose elements are the arguments"
#define Q_int_vector s7_make_circular_signature(sc, 1, 2, sc->is_int_vector_symbol, sc->is_integer_symbol)

                    s7_int len;
                    s7_pointer vec;

                    len = safe_list_length(args);
                    vec = make_simple_int_vector(sc, len);
                    if (len > 0)
                    {
                        s7_int i;
                        s7_pointer x;
                        for (x = args, i = 0; is_pair(x); x = cdr(x), i++)
                        {
                            s7_pointer p;
                            p = car(x);
                            if (is_t_integer(p))
                                int_vector(vec, i) = integer(p);
                            else
                            {
#if WITH_GMP
                                if (is_t_big_integer(p))
                                    int_vector(vec, i) = big_integer_to_s7_int(big_integer(p));
                                else
#endif
                                    return(method_or_bust(sc, p, sc->int_vector_symbol, copy_list(sc, args), T_INTEGER, i + 1));
                            }
                        }
                    }
                    return(vec);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x313be
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fdf4
testq %r15, %r15
jle 0x63484
xorl %r15d, %r15d
movq %r14, %rcx
cmpb $0x1, (%rcx)
jne 0x63484
movq 0x8(%rcx), %r12
cmpb $0xb, (%r12)
jne 0x6348e
movq 0x8(%r12), %rdx
movq 0x10(%rax), %rsi
movq %rdx, (%rsi,%r15,8)
movq 0x10(%rcx), %rcx
incq %r15
jmp 0x6345e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xfb8(%rbx), %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35492
incl %r15d
pushq $0xb
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
movl %r15d, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_byte_vector
static s7_pointer g_byte_vector(s7_scheme *sc, s7_pointer args)
                {
#define H_byte_vector "(byte-vector ...) returns a byte-vector whose elements are the arguments"
#define Q_byte_vector s7_make_circular_signature(sc, 1, 2, sc->is_byte_vector_symbol, sc->is_byte_symbol)

                    s7_int i, len;
                    s7_pointer vec, x;
                    uint8_t *str;

                    len = s7_list_length(sc, args);
                    vec = make_simple_byte_vector(sc, len);
                    str = byte_vector_bytes(vec);

                    for (i = 0, x = args; is_pair(x); i++, x = cdr(x))
                    {
                        s7_pointer byte;
                        s7_int b;
                        byte = car(x);
                        if (is_t_integer(byte))
                            b = integer(byte);
                        else
                        {
#if WITH_GMP
                            if (is_t_big_integer(byte))
                                b = big_integer_to_s7_int(big_integer(byte));
                            else
#endif
                                return(method_or_bust(sc, byte, sc->byte_vector_symbol, copy_list(sc, args), T_INTEGER, i + 1));
                        }
                        if ((b < 0) || (b > 255))
                            return(simple_wrong_type_argument_with_type(sc, sc->byte_vector_symbol, byte, an_unsigned_byte_string));
                        str[i] = (uint8_t)b;
                    }
                    return(vec);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2dada
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fe85
movq 0x10(%rax), %rcx
xorl %r15d, %r15d
movq %r14, %rdx
cmpb $0x1, (%rdx)
jne 0x63776
movq 0x8(%rdx), %r12
cmpb $0xb, (%r12)
jne 0x63780
movq 0x8(%r12), %rsi
cmpq $0xff, %rsi
ja 0x637b6
movb %sil, (%rcx,%r15)
incq %r15
movq 0x10(%rdx), %rdx
jmp 0x6374b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xc28(%rbx), %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35492
incl %r15d
pushq $0xb
popq %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
movl %r15d, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcd70
movq 0xc28(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xbe891(%rip), %r8      # 0x122060
movq %rbx, %rdi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x639d1
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x2fe85
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 0x32f28
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x639f7
movq %r14, %rdi
callq 0x9c27
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)
pushq $0x13
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/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 0x63a93
movq 0x8(%r15), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xd239
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 0x32f28
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x63ab9
movq %r14, %rdi
callq 0x9c27
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)
pushq $0x18
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table
static s7_pointer g_hash_table(s7_scheme *sc, s7_pointer args)
                {
#define H_hash_table "(hash-table ...) returns a hash-table containing the symbol/value pairs passed as its arguments. \
                    That is, (hash-table 'a 1 'b 2) returns a new hash-table with the two key/value pairs preinstalled."
#define Q_hash_table s7_make_circular_signature(sc, 1, 2, sc->is_hash_table_symbol, sc->T)

                    s7_int len;
                    s7_pointer ht;

                    len = safe_list_length(args);
                    if (len & 1)
                        return(s7_error(sc, sc->wrong_number_of_args_symbol,
                                    set_elist_2(sc, wrap_string(sc, "hash-table got an odd number of arguments: ~S", 45), args)));
                    len /= 2;

                    ht = s7_make_hash_table(sc, (len > sc->default_hash_table_length) ? len : sc->default_hash_table_length);
                    if (len > 0)
                    {
                        s7_int ht_loc;
                        s7_pointer x, y;
                        ht_loc = s7_gc_protect_1(sc, ht); /* hash_table_set can cons (but only if ht=let??), so we need to protect this */

                        for (x = args, y = cdr(args); is_pair(x); x = cddr(x), y = unchecked_cdr(cdr(y)))
                            if (car(y) != sc->F)
                                hash_table_add(sc, ht, car(x), car(y));

                        s7_gc_unprotect_at(sc, ht_loc);
                    }
                    return(ht);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x313be
movq %rax, %r12
testb $0x1, %r12b
jne 0x63b86
sarq %r12
movq 0x270(%rbx), %rsi
cmpq %rsi, %r12
cmovgq %r12, %rsi
movq %rbx, %rdi
callq 0x2a5ea
movq %rax, %r15
testq %r12, %r12
jle 0x63bf6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x89a9
movq %rax, %r12
movq %r14, %rax
cmpb $0x1, (%r14)
jne 0x63beb
movq 0x10(%rax), %r13
movq 0x8(%r13), %rcx
cmpq 0x120(%rbx), %rcx
je 0x63b78
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcbaa5
movq 0x10(%r14), %rax
movq 0x10(%rax), %r14
movq 0x10(%r13), %rax
jmp 0x63b4e
movq 0x1900(%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 0x83efc(%rip), %rcx     # 0xe7aad
movq %rcx, 0x10(%rax)
movq $0x2d, 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 0x2cdc0
jmp 0x63bf6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8b00
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_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), %r15
cmpb $0x1b, (%r15)
jne 0x63c98
movq 0x10(%r14), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%r15)
movq 0x20(%rax), %r12
movq 0x10(%r14), %rax
movq 0x10(%rax), %rdx
cmpq 0x110(%rbx), %rdx
je 0x63cfb
cmpq 0x120(%rbx), %r12
je 0x63cc0
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa8fcd
movq 0xf68(%rbx), %rdx
pushq $0x1b
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcd70
movq 0x1900(%rbx), %r12
movq 0xbe3ca(%rip), %rax     # 0x122098
movq 0x6e8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %r15, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e8(%rbx), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2cdc0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x63d32
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
jmp 0x2a7e4
movq 0xf70(%rdi), %rdx
pushq $0x1b
popq %r8
jmp 0xb7b5b
// File: /workspace/github_c_makefile_star2_O2/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 0x63d73
movq 0x28(%rsi), %rax
movq 0x18(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x63d8d
leaq 0xb1be3(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x63dc6
movq 0xf60(%rbx), %rdx
pushq $0x1b
popq %r8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x77745
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x63dac
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_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 0x646bc
movq 0x8(%rcx), %rcx
cmpb $0x1c, (%rcx)
jne 0x64758
cmpq 0x150(%rbx), %rcx
cmovneq %rcx, %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsi), %rdi
movq %rdi, (%rbx)
cmpq $0x0, 0x6a0(%rbx)
jle 0x646ef
cmpb $0x1, (%rdi)
jne 0x646ef
movl $0x2000, %esi           # imm = 0x2000
movq %rbx, %rdi
callq 0x2f187
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x7b77c
movq %rax, (%rbx)
jmp 0x646fb
cmpw $0x801, (%rdi)          # imm = 0x801
jne 0x646fb
callq 0xa1b8f
movq 0x50(%rbx), %rax
movq %rax, %rcx
subq 0x48(%rbx), %rcx
cmpq $0x5f, %rcx
jg 0x64720
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 0xb11f6(%rip), %rdx     # 0x115960
movq 0x140(%rbx), %r8
movq 0xb51e0(%rip), %r9      # 0x119958
movq %rbx, %rdi
popq %rbx
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x64840
movq 0x10(%r14), %rcx
movq 0x110(%rbx), %rax
cmpq %rax, %rcx
je 0x647c4
movq 0x8(%rcx), %rcx
cmpb $0x1c, (%rcx)
jne 0x64861
cmpq 0x150(%rbx), %rcx
cmovneq %rcx, %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0xc73c7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe138
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
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xeb0(%rbx), %rdx
pushq $0x13
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcd70
movq 0xeb0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xb10ed(%rip), %rdx     # 0x115960
movq 0x140(%rbx), %r8
movq 0xb50d7(%rip), %r9      # 0x119958
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/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 0x65d09
movq %rsi, %rdx
movq 0x8(%rsi), %rbx
cmpb $0x13, (%rbx)
jne 0x65d14
movq 0x1928(%r14), %rsi
movq %r14, %rdi
callq 0x2cdc0
movq 0x130(%r14), %rbx
jmp 0x65d23
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
jmp 0x65d1e
movq 0x10(%rdx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2cdc0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x65f36
movq %rsi, %r14
movq 0x8(%rsi), %r15
cmpq %rax, %r15
je 0x65f36
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2db34
movq %rbx, %rdi
testb %al, %al
je 0x65f43
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x38c2b
movq 0x138(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa2425
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_documentation
static s7_pointer g_documentation(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer p;
#define H_documentation "(documentation obj) returns obj's documentation string"
#define Q_documentation s7_make_signature(sc, 2, sc->is_string_symbol, sc->T) /* should (documentation 1) be an error? */

                    p = car(args);
                    if (is_symbol(p))
                    {
                        if ((symbol_has_help(p)) &&
                                (is_global(p)))
                            return(s7_make_string(sc, symbol_help(p)));
                        p = s7_symbol_value(sc, p);
                    }

                    /* (documentation func) should act like (documentation abs) -- available without (openlet (funclet func)) or (openlet func)
                     *   so we check that case ahead of time here, rather than going through check_method which does not
                     *   call find_let unless has_active_methods(sc, func).  Adding T_HAS_METHODS to all closures causes other troubles.
                     */
                    if (has_closure_let(p))
                    {
                        s7_pointer func;
                        func = funclet_entry(sc, p, sc->documentation_symbol);
                        if (func)
                            return(s7_apply_function(sc, func, args));
                    }

                    /* it would be neat if this would work (define x (let ((+documentation+ "hio")) (vector 1 2 3))) (documentation x) */
                    check_method(sc, p, sc->documentation_symbol, args);
                    return(s7_make_string(sc, s7_documentation(sc, p)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movb (%r15), %al
cmpb $0xa, %al
jne 0x660cb
movq 0x8(%r15), %rax
testb $0x20, 0x3(%rax)
je 0x660bb
testb $0x1, 0x2(%r15)
jne 0x6617b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x94b4
movq %rax, %r15
movb (%rax), %al
movzbl %al, %eax
leaq 0xaf83b(%rip), %rcx     # 0x115910
cmpb $0x1, (%rax,%rcx)
jne 0x660fd
movq 0xe90(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31541
testq %rax, %rax
je 0x660fd
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
jmp 0x6614a
testb $0x40, 0x3(%r15)
je 0x6615a
cmpb $0x1, 0x24c(%rbx)
jne 0x6615a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88f3
movq 0xe90(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x6615a
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x314d5
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd1fd
movq 0x20(%rax), %rax
movq 0x18(%rax), %rsi
movq %rbx, %rdi
jmp 0x6616b
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testb $0x40, 0x3(%r15)
je 0x661f7
cmpb $0x1, 0x24c(%rbx)
jne 0x661f7
movq %rsi, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88f3
movq 0xf80(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x661f7
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x315e3
testq %rax, %rax
je 0x6621d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd1fd
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x666b2
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rcx
cmpb $0x27, (%rcx)
jbe 0x66701
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x328e3
movq %rbx, %rax
popq %rbx
retq
movq 0xe78(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xaf294(%rip), %rdx     # 0x115958
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 0x81779(%rip), %rax     # 0xe7e69
movq %rax, 0x10(%r9)
movq $0x16, 0x8(%r9)
movq %rbx, %rcx
jmp 0x6674c
movq 0xe78(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xaf24d(%rip), %rdx     # 0x115960
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 0x81729(%rip), %rax     # 0xe7e69
movq %rax, 0x10(%r9)
movq $0x16, 0x8(%r9)
popq %rbx
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x6679f
movq 0x8(%rax), %rsi
testq %rsi, %rsi
js 0x667ba
movl $0x20000000, %edx       # imm = 0x20000000
cmpq %rdx, %rsi
cmovbq %rsi, %rdx
movq 0x8(%rcx), %rsi
movq %rbx, %rdi
callq 0x32378
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %rax
popq %rbx
retq
movq 0xfd0(%rbx), %rdx
pushq $0xb
popq %r8
pushq $0x2
popq %r9
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xcd70
movq 0xfd0(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0xaf194(%rip), %rdx     # 0x115960
movq 0xb3275(%rip), %r8      # 0x119a48
movq %rbx, %rdi
movq %rax, %rcx
popq %rbx
jmp 0xcb8f
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x38b04
testq %rax, %rax
je 0x66adf
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_O2/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 0x66b1e
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 0x80cb0(%rip), %rsi     # 0xe77d5
movq %rbx, %rdi
callq 0x94d4
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xb2fc1(%rip), %r8      # 0x119b00
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x66c5a
movq %rsi, %r12
cmpq $0x0, 0x6a0(%rbx)
jle 0x66c25
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2cd63
testb %al, %al
je 0x66c25
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 0x8129e(%rip), %rax     # 0xe7eaf
movq %rax, 0x10(%rdx)
movq $0x1a, 0x8(%rdx)
movq %rbx, %rdi
callq 0x2cdc0
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpq 0x110(%rbx), %rax
je 0x66cbc
movq 0x8(%rax), %rdx
cmpb $0xb, (%rdx)
jne 0x66c90
movq 0x8(%rdx), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xcc8fd
jmp 0x66ccc
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x66c6c
movq 0x8(%rax), %rdx
cmpb $0xb, (%rdx)
jne 0x66c90
cmpq %r15, %r14
leaq 0xaece2(%rip), %rax     # 0x115958
leaq 0xaecd3(%rip), %rcx     # 0x115950
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 0xb2e0f(%rip), %r8      # 0x119ab8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd456
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x86b07
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc049
// File: /workspace/github_c_makefile_star2_O2/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 0x66db2
movq %rdi, %rbx
cmpb $0x1, (%r14)
jne 0x66d4f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2dada
testq %rax, %rax
jle 0x66d4f
movb $0x1, %cl
movq %r14, %rax
cmpb $0x1, %cl
jne 0x66dbb
movq 0x8(%rax), %rdx
cmpb $0xa, (%rdx)
jne 0x66dc0
movq 0x10(%rax), %rax
movb (%rax), %cl
jmp 0x66d39
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 0x81150(%rip), %rcx     # 0xe7eca
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 0x2cdc0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %r15
jmp 0x66db2
movq 0xee0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xb2cd7(%rip), %r8      # 0x119ab0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x66e8c
cmpb $0x1, (%rbx)
jne 0x66e24
movb $0x1, %dl
movq %rbx, %rcx
cmpb $0x1, %dl
jne 0x66e1f
movq 0x8(%rcx), %rdx
cmpb $0x13, (%rdx)
jne 0x66e24
movq 0x10(%rcx), %rcx
movb (%rcx), %dl
jmp 0x66e09
cmpq %rax, %rcx
je 0x66e8c
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 0x81096(%rip), %rcx     # 0xe7ee5
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 0x2cdc0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_cload_directory_set
static s7_pointer g_cload_directory_set(s7_scheme *sc, s7_pointer args)
    {
        /* this sets the directory for cload.scm's output */
        s7_pointer cl_dir;
        cl_dir = cadr(args);
        if (!is_string(cl_dir))
            return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *cload-directory* to ~S", 33), cadr(args))));
        s7_symbol_set_value(sc, sc->cload_directory_symbol, cl_dir);
        if (safe_strlen(string_value(cl_dir)) > 0)
            s7_add_to_load_path(sc, (const char *)(string_value(cl_dir)));
        /* should this remove the previous *cload-directory* name first? or not affect *load-path* at all? */
        return(cl_dir);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rbx
cmpb $0x13, (%rbx)
jne 0x66ed6
movq 0xdf8(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xb0e7
movq 0x10(%rbx), %r15
movq %r15, %rdi
callq 0x8d06
testq %rax, %rax
jle 0x66f42
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a353
jmp 0x66f42
movq 0xea8(%r14), %rbx
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x80fff(%rip), %rcx     # 0xe7f01
movq %rcx, 0x10(%rax)
movq $0x21, 0x8(%rax)
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%r14), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2cdc0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_autoloader
static s7_pointer g_autoloader(s7_scheme *sc, s7_pointer args)
    {
#define H_autoloader "(*autoload* sym) returns the autoload info for the symbol sym, or #f."
#define Q_autoloader s7_make_signature(sc, 2, sc->T, sc->is_symbol_symbol)
        s7_pointer sym;

        sym = car(args);
        if (!is_symbol(sym))
        {
            check_method(sc, sym, sc->autoloader_symbol, args);
            return(s7_wrong_type_arg_error(sc, "*autoload*", 1, sym, "a symbol"));
        }
        if (sc->autoload_names)
        {
            const char *file;
            bool loaded = false;
            file = find_autoload_name(sc, sym, &loaded, false);
            if (file)
                return(s7_make_string(sc, file));
        }
        if (is_hash_table(sc->autoload_table))
            return(s7_hash_table_ref(sc, sc->autoload_table, sym));

        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0xa, (%r14)
jne 0x66f9f
cmpq $0x0, 0x2160(%rbx)
je 0x67026
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7da8d
testq %rax, %rax
je 0x67026
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd1fd
testb $0x40, 0x3(%r14)
je 0x66fff
cmpb $0x1, 0x24c(%rbx)
jne 0x66fff
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0xc20(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x66fff
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
leaq 0x795a8(%rip), %rsi     # 0xe05ae
leaq 0x71076(%rip), %r8      # 0xd8083
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc2b0
movq 0x2140(%rbx), %rsi
cmpb $0x1b, (%rsi)
jne 0x67041
movq %rbx, %rdi
movq %r14, %rdx
callq *0x18(%rsi)
movq 0x20(%rax), %rax
jmp 0x67048
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq