LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3a070
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x34da0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jle 0x9a2c4
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x9a2c2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x9a27c
jmp 0x9a2c4
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1b9d10
testb $0x1, %al
jne 0x9ac0f
jmp 0x9ad23
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x9ac45
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x9ac57
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x9ac98
movq 0x30(%rsp), %rcx
leaq 0x17b7f2(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x9ad0e
jmp 0x9ac9a
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x9acbe
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0xb, (%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x9ad4e
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rax
movq 0x1598(%rax), %rdx
movq 0x40(%rsp), %rcx
movl $0x15, %r8d
callq 0xcfd30
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1b9d10
testb $0x1, %al
jne 0x9ad82
jmp 0x9add4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x9adb2
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x9adc8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x9ae03
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x15a0(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x15, %r8d
callq 0xcfd30
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x3a070
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x370c0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jle 0x9b8a0
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x9b89e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x9b819
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x9b87b
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0xfb8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x44270
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movq 0x28(%rsp), %rax
addq $0x1, %rax
movl %eax, %r9d
movl $0xb, %r8d
callq 0x13c50
movq %rax, 0x50(%rsp)
jmp 0x9b8aa
jmp 0x9b87d
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x9b7d0
jmp 0x9b8a0
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x9c4b2
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0x15f0(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x9c431
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x70(%rsp)
jmp 0x9c51b
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0x15f0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x371c0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x36f70
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x3e9e0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x18, %eax
je 0x9c642
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0xc40(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x9c5c1
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rcx
movl $0x18, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x70(%rsp)
jmp 0x9c6ad
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0xc40(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x146a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x36f70
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x3e9e0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_make_weak_hash_table
static s7_pointer g_make_weak_hash_table(s7_scheme *sc, s7_pointer args)
                {
#define H_make_weak_hash_table "(make-weak-hash-table (size 8) eq-func typers) returns a new weak hash table"
#define Q_make_weak_hash_table s7_make_signature(sc, 4, sc->is_weak_hash_table_symbol, sc->is_integer_symbol, \
        s7_make_signature(sc, 3, sc->is_procedure_symbol, sc->is_pair_symbol, sc->not_symbol), \
        s7_make_signature(sc, 2, sc->is_pair_symbol, sc->not_symbol))
                    s7_pointer table;
                    table = g_make_hash_table_1(sc, args, sc->make_weak_hash_table_symbol);
                    set_weak_hash_table(table);
                    weak_hash_iters(table) = 0;
                    return(table);
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x12e8(%rax), %rdx
callq 0x1cd300
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rcx
orq $0x8000000, %rcx        # imm = 0x8000000
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x28(%rax), %rax
movl $0x0, 0xc(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1b, %eax
je 0x9c9af
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0xf68(%rax), %rdx
movq 0x20(%rsp), %rcx
movl $0x1b, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x30(%rsp)
jmp 0x9ca7b
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
callq 0x2a770
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x9c9fa
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x9ca7b
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x9ca5a
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x1900(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x1861b5(%rip), %rsi    # 0x222be8
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0xf240
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x30(%rsp)
jmp 0x9ca7b
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdx
callq 0x16bc20
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x10000ff, %rax        # imm = 0x10000FF
cmpq $0x1b, %rax
je 0x9caf3
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0xf70(%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1b, %r8d
movl $0x1, %r9d
callq 0x192ea0
movq %rax, 0x20(%rsp)
jmp 0x9cb25
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
callq 0x2a7b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1b, %eax
je 0x9cb83
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x38(%rsp), %rax
movq 0xf60(%rax), %rdx
movq 0x30(%rsp), %rcx
movl $0x1b, %r8d
callq 0xcfd30
movq %rax, 0x40(%rsp)
jmp 0x9cc4c
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x9cbc1
movq 0x28(%rsp), %rcx
leaq 0x1798ca(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x9cc38
jmp 0x9cbc3
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x9cbe7
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0xb, (%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0xa117d
movq (%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
jne 0xa115c
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x1928(%rax), %rsi
movq (%rsp), %rdx
callq 0x2f940
movq 0x8(%rsp), %rax
movq 0x130(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xa11a4
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x2f940
movq %rax, 0x10(%rsp)
jmp 0xa11a4
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x110(%rax), %rdx
callq 0x2f940
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa1a84
movq 0x18(%rsp), %rax
movq 0x138(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa1af5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa1ab8
movq 0x18(%rsp), %rax
movq 0x138(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa1af5
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x31a40
testb $0x1, %al
jne 0xa1ae1
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15cad0
movq %rax, 0x20(%rsp)
jmp 0xa1af5
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x47b10
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0xa2051
movq 0x38(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0xa2051
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x9a10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0xf80(%rax), %rdx
callq 0x98d0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0xa2051
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x44270
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x40(%rsp)
jmp 0xa2098
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x3a660
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xa2084
movq 0x38(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0xa2098
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x14630
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0xa2cf4
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0xfd0(%rax), %rdx
movq 0x20(%rsp), %rcx
movl $0xb, %r8d
movl $0x2, %r9d
callq 0x13c50
movq %rax, 0x30(%rsp)
jmp 0xa2d9f
movq 0x18(%rsp), %rdi
callq 0x10790
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jge 0xa2d3f
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xfd0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x173769(%rip), %rdx    # 0x216490
movq 0x18(%rsp), %rcx
movq 0x177845(%rip), %r8     # 0x21a578
callq 0x13880
movq %rax, 0x30(%rsp)
jmp 0xa2d9f
cmpq $0x20000000, 0x10(%rsp) # imm = 0x20000000
jle 0xa2d53
movq $0x20000000, 0x10(%rsp) # imm = 0x20000000
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x3cbf0
testb $0x1, %al
jne 0xa2d71
jmp 0xa2d84
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xa2d95
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_emergency_exit
static s7_pointer g_emergency_exit(s7_scheme *sc, s7_pointer args)
                {
#define H_emergency_exit "(emergency-exit obj) exits s7 immediately"
#define Q_emergency_exit s7_make_signature(sc, 2, sc->T, sc->T)

                    s7_pointer obj;
#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1
#endif

                    if (is_null(args))
                        _exit(EXIT_SUCCESS);          /* r7rs spec says use _exit here */
                    obj = car(args);
                    if (obj == sc->F)
                        _exit(EXIT_FAILURE);
                    if ((obj == sc->T) || (!s7_is_integer(obj)))
                        _exit(EXIT_SUCCESS);
                    _exit((int)s7_integer(obj));
                    return(sc->F);
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa3268
xorl %edi, %edi
callq 0x90c0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0xa3291
movl $0x1, %edi
callq 0x90c0
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x118(%rcx), %rax
je 0xa32b0
movq (%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0xa32b7
xorl %edi, %edi
callq 0x90c0
movq (%rsp), %rdi
callq 0x10790
movl %eax, %edi
callq 0x90c0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x478a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xa3371
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq (%rsp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0xa3382
movq 0x18(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x14, %eax
je 0xa33ff
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
leaq 0x1503c2(%rip), %rsi    # 0x1f3790
callq 0xb400
movq (%rsp), %rdi
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x17723d(%rip), %r8     # 0x21a630
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0xa342d
movq 0x18(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa3849
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0xa39c0
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa395e
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x31900
cmpq $0x0, %rax
jg 0xa38d8
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x1505e5(%rip), %rsi    # 0x1f3e85
movl $0x1a, %edx
callq 0xb880
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
callq 0xb830
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
jmp 0xa39c0
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa3952
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xa3940
movq 0x48(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0xee0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x48(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x176caf(%rip), %r8     # 0x21a5e0
callq 0x14a60
movq %rax, 0x50(%rsp)
jmp 0xa39c0
jmp 0xa3942
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xa38e2
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xa39c0
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
leaq 0x1504f7(%rip), %rsi    # 0x1f3e85
movl $0x1a, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
callq 0xb830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa3a10
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0xa3b78
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa3b0c
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa3ae3
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0xa3ace
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x150412(%rip), %rsi    # 0x1f3ea0
movl $0x1b, %edx
callq 0xb880
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
callq 0xb830
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
jmp 0xa3b78
jmp 0xa3ad0
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0xa3a3b
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa3b0a
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0xa3b78
jmp 0xa3b0c
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x150363(%rip), %rsi    # 0x1f3ea0
movl $0x1b, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
callq 0xb830
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0xa3c29
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x1502cf(%rip), %rsi    # 0x1f3ebc
movl $0x21, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
callq 0xb830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x30(%rsp)
jmp 0xa3c75
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xdf8(%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0xffd0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa430
cmpq $0x0, %rax
jle 0xa3c6b
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x29fc0
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xa3d87
movq 0x38(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0xa3d5b
movq 0x48(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0xa3d5b
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x9a10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rax
movq 0xc20(%rax), %rdx
callq 0x98d0
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0xa3d5b
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x44270
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x50(%rsp)
jmp 0xa3e1d
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rcx
leaq 0x148377(%rip), %rsi    # 0x1ec0e3
movl $0x1, %edx
leaq 0x13fe40(%rip), %r8     # 0x1e3bb8
callq 0x12540
movq %rax, 0x50(%rsp)
jmp 0xa3e1d
movq 0x48(%rsp), %rax
cmpq $0x0, 0x2160(%rax)
je 0xa3dd6
movb $0x0, 0x27(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x27(%rsp), %rdx
xorl %ecx, %ecx
callq 0xdfea0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xa3dd4
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x14630
movq %rax, 0x50(%rsp)
jmp 0xa3e1d
jmp 0xa3dd6
movq 0x48(%rsp), %rax
movq 0x2140(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1b, %eax
jne 0xa3e0c
movq 0x48(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x2140(%rax), %rsi
movq 0x38(%rsp), %rdx
callq 0x2a770
movq %rax, 0x50(%rsp)
jmp 0xa3e1d
movq 0x48(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_sharp_readers_set
static s7_pointer g_sharp_readers_set(s7_scheme *sc, s7_pointer args)
    {
        /* new value must be either () or a proper list of conses (char . func) */
        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_pair(car(x))) ||
                        (!s7_is_character(caar(x))) ||
                        (!s7_is_procedure(cdar(x))))
                    return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *#readers* to ~S", 26), 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 *#readers* to ~S", 26), cadr(args))));
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa43b0
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0xa4546
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa44da
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa44b1
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xa442b
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x14430
testb $0x1, %al
jne 0xa4415
jmp 0xa442b
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x397c0
testb $0x1, %al
jne 0xa449c
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x14fb07(%rip), %rsi    # 0x1f3f63
movl $0x1a, %edx
callq 0xb880
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
callq 0xb830
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
jmp 0xa4546
jmp 0xa449e
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0xa43db
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xa44d8
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0xa4546
jmp 0xa44da
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0xea8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x14fa58(%rip), %rsi    # 0x1f3f63
movl $0x1a, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
callq 0xb830
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_set_outlet
static s7_pointer g_set_outlet(s7_scheme *sc, s7_pointer args)
    {
        /* (let ((a 1)) (let ((b 2)) (set! (outlet (curlet)) (rootlet)) ((curlet) 'a))) */
        s7_pointer env, new_outer;

        env = car(args);
        if (!is_let(env))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 1, env, "a let"));
        if ((is_immutable(env)) || (env == sc->s7_let))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 1, env, "a mutable let"));

        new_outer = cadr(args);
        if (!is_let(new_outer))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 2, new_outer, "a let"));

        if (env != sc->rootlet)
            set_outlet(env, (new_outer == sc->rootlet) ? sc->nil : new_outer);
        return(new_outer);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0xa45f5
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x14f9a4(%rip), %rsi    # 0x1f3f7e
movl $0x1, %edx
leaq 0x14a809(%rip), %r8     # 0x1eedef
callq 0x12540
movq %rax, 0x30(%rsp)
jmp 0xa46eb
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
jne 0xa461c
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x2150(%rcx), %rax
jne 0xa4648
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x14f951(%rip), %rsi    # 0x1f3f7e
movl $0x1, %edx
leaq 0x14eea7(%rip), %r8     # 0x1f34e0
callq 0x12540
movq %rax, 0x30(%rsp)
jmp 0xa46eb
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0xa4690
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rcx
leaq 0x14f906(%rip), %rsi    # 0x1f3f7e
movl $0x2, %edx
leaq 0x14a76b(%rip), %r8     # 0x1eedef
callq 0x12540
movq %rax, 0x30(%rsp)
jmp 0xa46eb
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x150(%rcx), %rax
je 0xa46e1
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x150(%rcx), %rax
jne 0xa46c9
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xa46d3
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)