LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_to_list
s7_pointer s7_vector_to_list(s7_scheme *sc, s7_pointer vect)
                {
                    s7_int i, len;
                    s7_pointer result;
                    len = vector_length(vect);
                    if (len == 0)
                        return(sc->nil);
                    check_heap_size(sc, len);
                    sc->v = sc->nil;
                    for (i = len - 1; i >= 0; i--)
                        sc->v = cons_unchecked(sc, vector_getter(vect)(sc, vect, i), sc->v);
                    result = sc->v;
                    sc->v = sc->nil;
                    return(result);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x3bbc7
movq %rsi, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3bbd4
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d0(%rbx)
movq %rcx, %rax
testq %r15, %r15
jle 0x3bbbe
incq %r15
leaq -0x2(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%r14)
movq %rax, %rcx
movq 0x4d0(%rbx), %rdx
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rax, 0x4d0(%rbx)
decq %r15
cmpq $0x1, %r15
ja 0x3bb6a
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d0(%rbx)
jmp 0x3bbce
movq 0x110(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: check_heap_size
static void check_heap_size(s7_scheme *sc, s7_int size)
#endif
        {
            s7_int free_cells;
            free_cells = sc->free_heap_top - sc->free_heap;
            if (free_cells < size)
            {
#if S7_DEBUGGING
                gc(sc, func, line);
#else
                gc(sc);
#endif
                while ((sc->free_heap_top - sc->free_heap) < size)
                    resize_heap(sc);
            }
        }

// Assembly:
movq 0x90(%rdi), %rax
subq 0x88(%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jge 0x3bc24
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8cc3f
movq 0x90(%r14), %rax
subq 0x88(%r14), %rax
sarq $0x3, %rax
cmpq %rbx, %rax
jge 0x3bc1d
movq %r14, %rdi
xorl %esi, %esi
callq 0x8c4d4
jmp 0x3bbfa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_simple_vector
static inline s7_pointer make_simple_vector(s7_scheme *sc, s7_int len) /* len >= 0 and < max */
                {
                    s7_pointer x;
                    block_t *b;
                    new_cell(sc, x, T_VECTOR | T_SAFE_PROCEDURE);
                    vector_length(x) = len;
                    b = mallocate_vector(sc, len * sizeof(s7_pointer));
                    vector_block(x) = b;
                    vector_elements(x) = (s7_pointer *)block_data(b);
                    vector_set_dimension_info(x, NULL);
                    vector_getter(x) = default_vector_getter;
                    vector_setter(x) = default_vector_setter;
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3bc79
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200015, (%rbx)       # imm = 0x200015
movq %r15, 0x8(%rbx)
shlq $0x3, %r15
testq %r15, %r15
jle 0x3bca9
movq %r14, %rdi
movq %r15, %rsi
callq 0x9357
jmp 0x3bd0f
movq 0x838(%r14), %rax
testq %rax, %rax
jne 0x3bcf4
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, 0x838(%r14)
movq %rax, %rcx
addq $0x28, %rcx
movl $0xff, %edx
movq %rcx, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
addq $0x28, %rcx
decl %edx
jne 0x3bcd2
movq $0x0, -0x10(%rcx)
movl $0x0, -0x20(%rcx)
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r14)
movl $0x0, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
movq $0x0, 0x20(%rax)
leaq 0x20520(%rip), %rax     # 0x5c249
movq %rax, 0x20(%rbx)
leaq 0x2051e(%rip), %rax     # 0x5c252
movq %rax, 0x28(%rbx)
movq 0x740(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x3bd67
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_simple_byte_vector
static s7_pointer make_simple_byte_vector(s7_scheme *sc, s7_int len)
                {
                    s7_pointer x;
                    block_t *b;
                    new_cell(sc, x, T_BYTE_VECTOR | T_SAFE_PROCEDURE);
                    b = mallocate(sc, len);
                    vector_block(x) = b;
                    byte_vector_bytes(x) = (uint8_t *)block_data(b);
                    vector_length(x) = len;
                    vector_set_dimension_info(x, NULL);
                    vector_getter(x) = byte_vector_getter;
                    vector_setter(x) = byte_vector_setter;
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3cd38
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200018, (%rbx)       # imm = 0x200018
movq %r14, %rdi
movq %r15, %rsi
callq 0x9357
movq %rax, 0x18(%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq $0x0, 0x20(%rax)
leaq 0x5cb5b(%rip), %rax     # 0x998d2
movq %rax, 0x20(%rbx)
leaq 0x5cb64(%rip), %rax     # 0x998e6
movq %rax, 0x28(%rbx)
movq 0x740(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x3cdb5
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: callocate
static block_t *callocate(s7_scheme *sc, size_t bytes)
    {
        block_t *p;
        p = mallocate(sc, bytes);
        if ((block_data(p)) && (block_index(p) != BLOCK_LIST))
        {
            if (block_index(p) >= 6)
                memclr64((void *)block_data(p), bytes);
            else memclr((void *)(block_data(p)), bytes);
        }
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x9357
movq %rax, %rbx
movq (%rax), %r15
testq %r15, %r15
je 0x3ce5e
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x3ce5e
cmpl $0x6, %eax
jl 0x3ce2b
cmpq $0x8, %r14
jb 0x3ce5e
shrq $0x3, %r14
cmpq $0x9, %r14
movl $0x8, %eax
cmovaeq %r14, %rax
leaq -0x8(,%rax,8), %rdx
andq $-0x40, %rdx
addq $0x40, %rdx
movq %r15, %rdi
xorl %esi, %esi
jmp 0x3ce59
cmpq $0x8, %r14
jb 0x3ce4c
movq %r14, %r12
andq $-0x8, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x8270
addq %r12, %r15
andl $0x7, %r14d
testq %r14, %r14
je 0x3ce5e
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8270
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_equal_any
static hash_entry_t *hash_equal_any(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    s7_int hash, loc;

                    hash = hash_loc(sc, table, key);
                    loc = hash & hash_table_mask(table);

                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if (hash_entry_raw_hash(x) == hash)
                            if (s7_is_equal(sc, hash_entry_key(x), key))
                                return(x);
                    return(sc->unentry);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rax
movzbl (%rdx), %ecx
callq *(%rax,%rcx,8)
movq %rax, %r12
movq 0x8(%r15), %rax
andq %r12, %rax
movq 0x10(%r15), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x3d416
leaq 0x115930(%rip), %r13    # 0x152d20
cmpq %r12, 0x10(%r15)
jne 0x3d40d
movq (%r15), %rsi
movzbl (%rsi), %eax
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq *(%r13,%rax,8)
testb %al, %al
jne 0x3d41d
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x3d3f0
movq 0x490(%r14), %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_map_real
static s7_int hash_map_real(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    return(hash_float_location(real(key)));
                    /* currently 1e300 goes to most-negative-fixnum! -> 0 after logand size, I hope
                     *
                     * we need round, not floor for the location calculation in the real/complex cases else
                     *    1-eps doesn't match 1.0, but 1+eps does.  And what if round(val) is too big for int?
                     *    lrint is complex and requires special compiler flags to get any speed (-fno-math-errno).
                     *    all we need is (int32_t)(val+0.5) -- all the other stuff is pointless in this context
                     */
                }

// Assembly:
movsd 0x8(%rdx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3d47d
andpd 0xcca69(%rip), %xmm0    # 0x109ec0
movsd 0xc8bf9(%rip), %xmm1    # 0x106058
ucomisd %xmm0, %xmm1
jbe 0x3d477
movsd 0xc8bf3(%rip), %xmm1    # 0x106060
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
retq
cvttsd2si %xmm0, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_map_vector
static s7_int hash_map_vector(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if ((vector_length(key) == 0) ||
                            (is_sequence(vector_element(key, 0))))
                        return(vector_length(key));
                    if ((vector_length(key) == 1) ||
                            (is_sequence(vector_element(key, 1))))
                        return(hash_loc(sc, table, vector_element(key, 0)));
                    return(vector_length(key) + hash_loc(sc, table, vector_element(key, 0)) + hash_loc(sc, table, vector_element(key, 1)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdx), %rbx
testq %rbx, %rbx
je 0x3d60a
movq %rdx, %r12
movq %rsi, %r14
movq 0x10(%rdx), %rcx
movq (%rcx), %rdx
movzbl (%rdx), %eax
leaq 0x1155d5(%rip), %rsi    # 0x152b80
cmpb $0x0, (%rax,%rsi)
jne 0x3d60c
movq (%rdx), %rax
btl $0x1e, %eax
jb 0x3d60c
movq %rdi, %r15
cmpq $0x1, %rbx
je 0x3d619
movq 0x8(%rcx), %rcx
movzbl (%rcx), %edi
cmpb $0x0, (%rdi,%rsi)
jne 0x3d619
testb $0x40, 0x3(%rcx)
jne 0x3d619
movq 0x20(%r14), %rcx
movzbl %al, %eax
movq %r15, %rdi
movq %r14, %rsi
callq *(%rcx,%rax,8)
movq %rax, %r13
movq 0x20(%r14), %rax
movq 0x10(%r12), %rcx
movq 0x8(%rcx), %rdx
movzbl (%rdx), %ecx
movq %r15, %rdi
movq %r14, %rsi
callq *(%rax,%rcx,8)
addq %rax, %rbx
addq %r13, %rbx
jmp 0x3d60c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x20(%r14), %rcx
movzbl %al, %eax
movq (%rcx,%rax,8), %rax
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_map_float_vector
static s7_int hash_map_float_vector(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (vector_length(key) == 0)
                        return(0);
                    if (vector_length(key) == 1)
                        return(hash_float_location(float_vector(key, 0)));
                    return(vector_length(key) + hash_float_location(float_vector(key, 0)) + hash_float_location(float_vector(key, 1)));
                }

// Assembly:
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x3d701
cmpq $0x1, %rax
jne 0x3d6c5
movq 0x10(%rdx), %rax
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3d74a
andpd 0xcc81b(%rip), %xmm0    # 0x109ec0
movsd 0xc89ab(%rip), %xmm1    # 0x106058
ucomisd %xmm0, %xmm1
jbe 0x3d6fc
movsd 0xc89a5(%rip), %xmm1    # 0x106060
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
retq
movq 0x10(%rdx), %rdx
movsd (%rdx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3d74d
andpd 0xcc7e5(%rip), %xmm0    # 0x109ec0
movsd 0xc8975(%rip), %xmm1    # 0x106058
ucomisd %xmm0, %xmm1
jbe 0x3d702
movsd 0xc896f(%rip), %xmm1    # 0x106060
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
jmp 0x3d707
cvttsd2si %xmm0, %rax
retq
cvttsd2si %xmm0, %rcx
addq %rax, %rcx
movsd 0x8(%rdx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3d751
andpd 0xcc7a3(%rip), %xmm0    # 0x109ec0
movsd 0xc8933(%rip), %xmm1    # 0x106058
ucomisd %xmm0, %xmm1
jbe 0x3d73e
movsd 0xc892d(%rip), %xmm1    # 0x106060
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
jmp 0x3d743
cvttsd2si %xmm0, %rax
addq %rax, %rcx
movq %rcx, %rax
retq
xorl %eax, %eax
retq
xorl %ecx, %ecx
jmp 0x3d707
xorl %eax, %eax
jmp 0x3d743
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_map_pair
static s7_int hash_map_pair(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    /* len+loc(car) is not horrible, but it means (for example) every list '(set! ...) is hashed to the same location,
                     *   so at least we need to take cadr into account if possible.  Better would combine the list_length
                     *   with stats like symbols/pairs/constants at top level, then use those to spread it out over all the locs.
                     */
                    s7_pointer p1;
                    s7_int loc = 0;

                    if (!is_sequence(car(key)))
                        loc = hash_loc(sc, table, car(key)) + 1;
                    else
                    {
                        if ((is_pair(car(key))) &&
                                (!is_sequence(caar(key))))
                            loc = hash_loc(sc, table, caar(key)) + 1;
                    }
                    p1 = cdr(key);
                    if (is_pair(p1))
                    {
                        if (!is_sequence(car(p1)))
                            loc += hash_loc(sc, table, car(p1)) + 1;
                        else
                        {
                            if ((is_pair(car(p1))) &&
                                    (!is_sequence(caar(p1))))
                                loc += hash_loc(sc, table, caar(p1)) + 1;
                        }
                    }
                    loc = (loc << 3) | len_upto_8(key);
                    return(loc);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdx), %rdx
movzbl (%rdx), %ecx
leaq 0x11532d(%rip), %r13    # 0x152b80
cmpb $0x0, (%rcx,%r13)
jne 0x3d863
movq (%rdx), %rax
btl $0x1e, %eax
jae 0x3d87f
cmpb $0x1, %cl
jne 0x3d897
movq 0x8(%rdx), %rdx
movzbl (%rdx), %eax
cmpb $0x0, (%rax,%r13)
jne 0x3d897
movq (%rdx), %rax
btl $0x1e, %eax
jb 0x3d897
movq 0x20(%r15), %rcx
movzbl %al, %eax
movq %r12, %rdi
movq %r15, %rsi
callq *(%rcx,%rax,8)
movq %rax, %r14
incq %r14
jmp 0x3d89a
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x3d8ec
movq 0x8(%rax), %rdx
movzbl (%rdx), %ecx
cmpb $0x0, (%rcx,%r13)
jne 0x3d8ba
movq (%rdx), %rax
btl $0x1e, %eax
jae 0x3d8d6
cmpb $0x1, %cl
jne 0x3d8ec
movq 0x8(%rdx), %rdx
movzbl (%rdx), %eax
cmpb $0x0, (%rax,%r13)
jne 0x3d8ec
movq (%rdx), %rax
btl $0x1e, %eax
jb 0x3d8ec
movq 0x20(%r15), %rcx
movzbl %al, %eax
movq %r12, %rdi
movq %r15, %rsi
callq *(%rcx,%rax,8)
addq %rax, %r14
incq %r14
cmpb $0x1, (%rbx)
jne 0x3d90a
xorl %ecx, %ecx
movq 0x10(%rbx), %rbx
leaq 0x1(%rcx), %rax
cmpb $0x1, (%rbx)
jne 0x3d90c
cmpl $0x7, %ecx
movq %rax, %rcx
jb 0x3d8f3
jmp 0x3d90c
xorl %eax, %eax
shlq $0x3, %r14
orq %rax, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_equal_syntax
static hash_entry_t *hash_equal_syntax(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    s7_int loc;
                    loc = hash_loc(sc, table, key) & hash_table_mask(table);
                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if ((is_syntax(hash_entry_key(x))) &&
                                (syntax_symbol(hash_entry_key(x)) == syntax_symbol(key))) /* the opcodes might differ, but the symbols should not */
                            return(x);
                    return(sc->unentry);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rax
movzbl (%rdx), %ecx
callq *(%rax,%rcx,8)
andq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x3da92
movq (%rax), %rcx
cmpb $0x9, (%rcx)
jne 0x3da8c
movq 0x8(%rcx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x3da99
movq 0x18(%rax), %rax
jmp 0x3da75
movq 0x490(%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_equal_eq
static hash_entry_t *hash_equal_eq(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    s7_int loc;
                    loc = hash_loc(sc, table, key) & hash_table_mask(table);
                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if (hash_entry_key(x) == key)
                            return(x);
                    return(sc->unentry);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rax
movzbl (%rdx), %ecx
callq *(%rax,%rcx,8)
andq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x3dad3
cmpq %rbx, (%rax)
je 0x3dada
movq 0x18(%rax), %rax
jmp 0x3dac3
movq 0x490(%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_string
static hash_entry_t *hash_string(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (is_string(key))
                    {
                        hash_entry_t *x;
                        s7_int key_len, hash_mask;
                        uint64_t hash;
                        const char *key_str;

                        key_len = string_length(key);
                        key_str = string_value(key);

                        if (string_hash(key) == 0)
                            string_hash(key) = raw_string_hash((const uint8_t *)string_value(key), string_length(key));
                        hash = string_hash(key);

                        hash_mask = hash_table_mask(table);
                        if (key_len <= 8)
                        {
                            for (x = hash_table_element(table, hash & hash_mask); x; x = hash_entry_next(x))
                                if ((hash == string_hash(hash_entry_key(x))) &&
                                        (key_len == string_length(hash_entry_key(x))))
                                    return(x);
                        }
                        else
                        {
                            for (x = hash_table_element(table, hash & hash_mask); x; x = hash_entry_next(x))
                                if ((hash == string_hash(hash_entry_key(x))) &&
                                        (key_len == string_length(hash_entry_key(x))) &&        /* these are scheme strings, so we can't assume 0=end of string */
                                        (strings_are_equal_with_length(key_str, string_value(hash_entry_key(x)), key_len)))
                                    return(x);
                        }
                    }
                    return(sc->unentry);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x13, (%rdx)
jne 0x3dbd0
movq %rdx, %r13
movq %rsi, %r12
movq 0x8(%rdx), %r14
movq 0x10(%rdx), %r15
movq 0x18(%rdx), %rbp
testq %rbp, %rbp
jne 0x3db6e
movq $0x0, 0x10(%rsp)
cmpq $0x8, %r14
jg 0x3db39
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x83e0
movq (%rbp), %rbp
jmp 0x3db6a
movq (%r15), %rbp
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
leaq 0x8(%r15), %rsi
cmpq $0x10, %r14
movl $0x10, %edx
cmovbq %r14, %rdx
addq $-0x8, %rdx
callq 0x83e0
leaq 0x8(%rsp), %rax
addq (%rax), %rbp
movq %rbp, 0x18(%r13)
movq 0x8(%r12), %rax
andq %rbp, %rax
movq 0x10(%r12), %rcx
movq (%rcx,%rax,8), %r12
cmpq $0x8, %r14
jg 0x3dba1
testq %r12, %r12
je 0x3dbd0
movq (%r12), %rax
cmpq 0x18(%rax), %rbp
jne 0x3db9a
cmpq 0x8(%rax), %r14
je 0x3dbd7
movq 0x18(%r12), %r12
jmp 0x3db85
testq %r12, %r12
je 0x3dbd0
movq (%r12), %rax
cmpq 0x18(%rax), %rbp
jne 0x3dbc9
cmpq 0x8(%rax), %r14
jne 0x3dbc9
movq 0x10(%rax), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x8c146
testb %al, %al
jne 0x3dbd7
movq 0x18(%r12), %r12
jmp 0x3dba1
movq 0x490(%rbx), %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_int
static hash_entry_t *hash_int(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (is_t_integer(key))
                    {
                        s7_int loc, hash_mask, kv;
                        hash_entry_t *x;

                        hash_mask = hash_table_mask(table);
                        kv = integer(key);
                        loc = kv & hash_mask;
                        for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                            if (integer(hash_entry_key(x)) == kv)
                                return(x);
                    }
                    return(sc->unentry);
                }

// Assembly:
cmpb $0xb, (%rdx)
jne 0x3dc15
movq 0x8(%rdx), %rcx
movq 0x8(%rsi), %rax
andq %rcx, %rax
movq 0x10(%rsi), %rdx
movq (%rdx,%rax,8), %rax
testq %rax, %rax
je 0x3dc15
movq (%rax), %rdx
cmpq %rcx, 0x8(%rdx)
je 0x3dc1c
movq 0x18(%rax), %rax
jmp 0x3dc01
movq 0x490(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_float
static hash_entry_t *hash_float(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    /* give the equality check some room. also inf == inf and nan == nan */
                    if (type(key) == T_REAL)
                    {
                        s7_double keyval;
                        s7_int hash_mask, loc;

                        hash_mask = hash_table_mask(table);
                        keyval = real(key);
                        loc = hash_float_location(keyval) & hash_mask;

                        return(hash_float_1(sc, table, loc, keyval));
                    }
                    return(sc->unentry);
                }

// Assembly:
cmpb $0xd, (%rdx)
jne 0x3dc5e
movq 0x8(%rsi), %rax
movsd 0x8(%rdx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3dc73
movapd 0xcc287(%rip), %xmm1    # 0x109ec0
andpd %xmm0, %xmm1
movsd 0xc8413(%rip), %xmm2    # 0x106058
ucomisd %xmm1, %xmm2
jbe 0x3dc66
movsd 0xc840d(%rip), %xmm2    # 0x106060
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %rdx
jmp 0x3dc6b
movq 0x490(%rdi), %rax
retq
cvttsd2si %xmm1, %rdx
andq %rax, %rdx
jmp 0x9a06b
xorl %edx, %edx
jmp 0x3dc6b
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: hash_symbol
static hash_entry_t *hash_symbol(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    for (x = hash_table_element(table, symbol_hmap(key) & hash_table_mask(table)); x; x = hash_entry_next(x))
                        if (key == hash_entry_key(x))
                            return(x);
                    return(sc->unentry);
                }

// Assembly:
movq 0x10(%rsi), %rax
movq %rdx, %rcx
sarq $0x8, %rcx
andq 0x8(%rsi), %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x3dc9a
cmpq %rdx, (%rax)
je 0x3dca1
movq 0x18(%rax), %rax
jmp 0x3dc8a
movq 0x490(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: resize_hash_table
static void resize_hash_table(s7_scheme *sc, s7_pointer table)
                {
                    s7_int hash_mask, loc, i, old_size, new_size;
                    hash_entry_t **new_els, **old_els;
                    block_t *np;
                    s7_pointer dproc;
                    s7_int entries;

                    dproc = hash_table_procedures(table); /* new block_t so we need to pass this across */
                    entries = hash_table_entries(table);
                    old_size = hash_table_mask(table) + 1;
                    new_size = old_size * 4;
                    hash_mask = new_size - 1;
                    np = (block_t *)callocate(sc, new_size * sizeof(hash_entry_t *));
                    new_els = (hash_entry_t **)(block_data(np));
                    old_els = hash_table_elements(table);

                    for (i = 0; i < old_size; i++)
                    {
                        hash_entry_t *x, *n;
                        for (x = old_els[i]; x; x = n)
                        {
                            n = hash_entry_next(x);
                            loc = hash_entry_raw_hash(x) & hash_mask;
                            hash_entry_next(x) = new_els[loc];
                            new_els[loc] = x;
                        }
                    }
                    liberate(sc, hash_table_block(table));
                    hash_table_set_block(table, np);
                    hash_table_elements(table) = new_els;
                    hash_table_mask(table) = new_size - 1;
                    hash_table_set_procedures(table, dproc);
                    hash_table_entries(table) = entries;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r13
movq 0x28(%rsi), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x1(%r13), %rsi
leaq 0x3(,%r13,4), %rbp
shlq $0x5, %rsi
callq 0x3cdd6
movq %rax, %r15
movq (%rax), %r12
testq %r13, %r13
js 0x3dd56
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x3dd4a
movq 0x18(%rdx), %rsi
movq 0x10(%rdx), %rdi
andq %rbp, %rdi
movq (%r12,%rdi,8), %r8
movq %r8, 0x18(%rdx)
movq %rdx, (%r12,%rdi,8)
movq %rsi, %rdx
testq %rsi, %rsi
jne 0x3dd2b
leaq 0x1(%rcx), %rdx
cmpq %r13, %rcx
movq %rdx, %rcx
jne 0x3dd22
movq 0x28(%rbx), %r13
movslq 0x8(%r13), %rax
cmpq $0x11, %rax
jne 0x3dd8b
movq (%r13), %rdi
testq %rdi, %rdi
je 0x3dd7a
callq 0x8050
movq $0x0, (%r13)
movl $0x0, 0x8(%r13)
addq $0x838, %r14            # imm = 0x838
jmp 0x3dd96
leaq (%r14,%rax,8), %r14
addq $0x838, %r14            # imm = 0x838
movq (%r14), %rax
movq %rax, 0x18(%r13)
movq %r13, (%r14)
movq %r15, 0x28(%rbx)
movq %r12, 0x10(%rbx)
movq %rbp, 0x8(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r15)
movq 0x28(%rbx), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_make_function
s7_pointer s7_make_function(s7_scheme *sc, const char *name, s7_function f, s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc)
                {
                    s7_pointer x;
                    x = alloc_pointer(sc);
#if S7_DEBUGGING
                    permanent_functions++;
#endif
                    x = make_function(sc, name, f, required_args, optional_args, rest_arg, doc, x, alloc_permanent_function(sc));
                    unheap(sc, x);
                    return(x);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0xec9f
movq %rax, %rbx
movl 0x7f4(%r14), %ecx
cmpl $0x80, %ecx
jne 0x3de22
movl $0x3400, %edi           # imm = 0x3400
callq 0x8480
movq %rax, 0x808(%r14)
xorl %ecx, %ecx
jmp 0x3de29
movq 0x808(%r14), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x7f4(%r14)
movl %ecx, %ecx
imulq $0x68, %rcx, %r10
addq %rax, %r10
subq $0x8, %rsp
movzbl %bpl, %r9d
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
pushq %r10
pushq %rbx
pushq 0x58(%rsp)
callq 0x3de7b
addq $0x20, %rsp
orb $0x40, 0x7(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_make_typed_function
s7_pointer s7_make_typed_function(s7_scheme *sc, const char *name, s7_function f,
                        s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc, s7_pointer signature)
                {
                    s7_pointer func;
                    func = s7_make_function(sc, name, f, required_args, optional_args, rest_arg, doc);
                    set_type_bit(func, T_SAFE_PROCEDURE);
                    if (signature) c_function_signature(func) = signature;
                    return(func);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
callq 0x3ddd8
orb $0x20, 0x2(%rax)
testq %rbx, %rbx
je 0x3e093
movq 0x8(%rax), %rcx
movq %rbx, 0x38(%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_define_function
s7_pointer s7_define_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc)
                {
                    s7_pointer func, sym;
                    func = s7_make_function(sc, name, fnc, required_args, optional_args, rest_arg, doc);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x3ddd8
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9afc
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbfdc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_define_safe_function
s7_pointer s7_define_safe_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc)
                {
                    /* returns (string->symbol name), not the c_proc_t func */
                    s7_pointer func, sym;
                    func = s7_make_safe_function(sc, name, fnc, required_args, optional_args, rest_arg, doc);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x3ddd8
movq %rax, %r15
orb $0x20, 0x2(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9afc
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbfdc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_define_typed_function
s7_pointer s7_define_typed_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg,
                        const char *doc, s7_pointer signature)
                {
                    /* returns (string->symbol name), not the c_proc_t func */
                    s7_pointer func, sym;
                    func = s7_make_typed_function(sc, name, fnc, required_args, optional_args, rest_arg, doc, signature);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    c_function_set_marker(func, NULL);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x3ddd8
movq %rax, %r15
orb $0x20, 0x2(%rax)
testq %r12, %r12
je 0x3e219
movq 0x8(%r15), %rax
movq %r12, 0x38(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9afc
movq %rax, %r14
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbfdc
movq 0x8(%r15), %rax
movq $0x0, 0x60(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_define_unsafe_typed_function
s7_pointer s7_define_unsafe_typed_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg,
                        const char *doc, s7_pointer signature)
                {
                    /* returns (string->symbol name), not the c_proc_t func */
                    s7_pointer func, sym;
                    func = s7_make_function(sc, name, fnc, required_args, optional_args, rest_arg, doc);
                    if (signature) c_function_signature(func) = signature;
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x3ddd8
movq %rax, %r15
testq %r12, %r12
je 0x3e288
movq 0x8(%r15), %rax
movq %r12, 0x38(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9afc
movq %rax, %r14
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbfdc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_define_macro
s7_pointer s7_define_macro(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc)
                {
                    s7_pointer func, sym;
                    func = s7_make_function(sc, name, fnc, required_args, optional_args, rest_arg, doc);
                    set_type(func, T_C_MACRO | T_DONT_EVAL_ARGS | T_UNHEAP); /* s7_make_function includes T_UNHEAP */
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x3ddd8
movq %rax, %r15
movabsq $0x400000000000202e, %rax # imm = 0x400000000000202E
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9afc
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbfdc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: mark_c_proc_star
static void mark_c_proc_star(s7_pointer p)
    {
        set_mark(p);
        if (!c_func_has_simple_defaults(p))
        {
            s7_pointer arg;
            for (arg = c_function_call_args(p); is_pair(arg); arg = cdr(arg))
                gc_mark(car(arg));
        }
    }

// Assembly:
movq (%rdi), %rax
movq %rax, %rcx
btsq $0x3f, %rcx
movq %rcx, (%rdi)
btl $0x12, %eax
jb 0x3e6f0
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq 0x60(%rax), %rbx
cmpb $0x1, (%rbx)
jne 0x3e6e9
leaq 0x1080a3(%rip), %r14    # 0x146770
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x3e6e0
movzbl %al, %eax
callq *(%r14,%rax,8)
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0x3e6cd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_make_safe_function_star
s7_pointer s7_make_safe_function_star(s7_scheme *sc, const char *name, s7_function fnc, const char *arglist, const char *doc)
                {
                    s7_pointer func;
                    func = s7_make_function_star(sc, name, fnc, arglist, doc);
                    set_type(func, typeflag(func) | T_SAFE_PROCEDURE);   /* don't step on the c_func_has_simple_defaults flag */
                    c_function_call_args(func) = permanent_list(sc, c_function_optional_args(func));
                    return(func);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3e325
movq %rax, %r14
orb $0x20, 0x2(%rax)
movq 0x20(%rax), %r15
movq 0x110(%rbx), %r12
testq %r15, %r15
jle 0x3e749
movabsq $0x4000000001000001, %r13 # imm = 0x4000000001000001
movq 0x110(%rbx), %rbp
movq %rbx, %rdi
callq 0xec9f
movq %r13, (%rax)
movq %rbp, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, %r12
decq %r15
jne 0x3e725
jmp 0x3e74c
movq %r12, %rax
movq 0x8(%r14), %rcx
movq %rax, 0x60(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: define_function_star_1
static void define_function_star_1(s7_scheme *sc, const char *name, s7_function fnc, const char *arglist, const char *doc, bool safe, s7_pointer signature)
                {
                    s7_pointer func, sym;
                    if (safe)
                        func = s7_make_safe_function_star(sc, name, fnc, arglist, doc);
                    else func = s7_make_function_star(sc, name, fnc, arglist, doc);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    if (signature) c_function_signature(func) = signature;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsp), %r12
testl %r9d, %r9d
je 0x3e798
callq 0x3e6f1
jmp 0x3e79d
callq 0x3e325
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9afc
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbfdc
testq %r12, %r12
je 0x3e7cd
movq 0x8(%r15), %rax
movq %r12, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_documentation
const char *s7_documentation(s7_scheme *sc, s7_pointer x)
                {
                    s7_pointer val;
                    if (is_symbol(x))
                    {
                        if (is_keyword(x)) return(NULL);
                        if (symbol_has_help(x))
                            return(symbol_help(x));
                        x = s7_symbol_value(sc, x); /* this is needed by Snd */
                    }

                    if ((is_any_c_function(x)) ||
                            (is_c_macro(x)))
                        return((char *)c_function_documentation(x));

                    if (is_syntax(x))
                        return(syntax_documentation(x));

                    val = funclet_entry(sc, x, sc->local_documentation_symbol);
                    if ((val) && (is_string(val)))
                        return(string_value(val));

                    return(NULL);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb (%rsi), %al
cmpb $0xa, %al
jne 0x3e828
testb $-0x80, 0x6(%rsi)
jne 0x3e85c
movq 0x8(%rsi), %rax
testb $0x20, 0x3(%rax)
jne 0x3e860
movq %rbx, %rdi
callq 0x9a93
movq %rax, %rsi
movb (%rax), %al
cmpb $0x2e, %al
jb 0x3e836
movq 0x8(%rsi), %rsi
addq $0x10, %rsi
jmp 0x3e868
cmpb $0x9, %al
jne 0x3e840
addq $0x20, %rsi
jmp 0x3e868
movq 0x16c0(%rbx), %rdx
movq %rbx, %rdi
callq 0x3e86d
testq %rax, %rax
je 0x3e85c
movq %rax, %rsi
cmpb $0x13, (%rax)
je 0x3e830
xorl %eax, %eax
jmp 0x3e86b
movq 0x20(%rax), %rsi
addq $0x18, %rsi
movq (%rsi), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: funclet_entry
static s7_pointer funclet_entry(s7_scheme *sc, s7_pointer x, s7_pointer sym)
    {
        if ((has_closure_let(x)) && (is_let(closure_let(x))))
        {
            s7_pointer val;
            val = symbol_to_local_slot(sc, sym, closure_let(x));
            if ((!is_slot(val)) && (is_let(outlet(closure_let(x)))))
                val = symbol_to_local_slot(sc, sym, outlet(closure_let(x)));
            if (is_slot(val))
                return(slot_value(val));
        }
        return(NULL);
    }

// Assembly:
movzbl (%rsi), %eax
leaq 0x108099(%rip), %rcx    # 0x146910
cmpb $0x1, (%rax,%rcx)
jne 0x3e8e4
movq 0x18(%rsi), %rsi
cmpb $0x1c, (%rsi)
jne 0x3e8e4
movq 0x20(%rdx), %rcx
testq %rcx, %rcx
je 0x3e8a4
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3e8a4
cmpq %rdx, 0x8(%rax)
je 0x3e8ab
movq 0x18(%rax), %rax
jmp 0x3e893
movq 0x128(%rdi), %rax
cmpb $0x20, (%rax)
je 0x3e8df
movq 0x10(%rsi), %rsi
cmpb $0x1c, (%rsi)
jne 0x3e8da
testq %rcx, %rcx
je 0x3e8d3
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3e8d3
cmpq %rdx, 0x8(%rax)
je 0x3e8da
movq 0x18(%rax), %rax
jmp 0x3e8c2
movq 0x128(%rdi), %rax
cmpb $0x20, (%rax)
jne 0x3e8e4
movq 0x10(%rax), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_set_documentation
const char *s7_set_documentation(s7_scheme *sc, s7_pointer sym, const char *new_doc)
                {
                    if (is_keyword(sym)) return(NULL);
                    if (is_symbol(sym))
                    {
                        symbol_set_has_help(sym);
                        symbol_set_help(sym, copy_string(new_doc));
                    }
                    return(new_doc);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testb $-0x80, 0x6(%rsi)
jne 0x3e91d
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0xa, (%rsi)
jne 0x3e91f
movq 0x8(%r14), %rax
orq $0x20000000, (%rax)     # imm = 0x20000000
movq %rbx, %rdi
callq 0xc157
movq 0x8(%r14), %rcx
movq 0x20(%rcx), %rcx
movq %rax, 0x18(%rcx)
jmp 0x3e91f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_help
const char *s7_help(s7_scheme *sc, s7_pointer obj)
                {
                    if (is_syntax(obj))
                        return(syntax_documentation(obj));

                    if (is_symbol(obj))
                    {
                        /* here look for name */
                        if (s7_documentation(sc, obj))
                            return(s7_documentation(sc, obj));
                        obj = s7_symbol_value(sc, obj);
                    }

                    if (is_procedure_or_macro(obj))
                        return(s7_documentation(sc, obj));

                    if (obj == sc->s7_let)
                        return("*s7* is a let that gives access to s7's internal state: e.g. (*s7* 'print-length)");

                    /* if is string, apropos? (can scan symbol table) */
                    return(NULL);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rsi), %eax
cmpl $0xa, %eax
je 0x3e947
cmpl $0x9, %eax
jne 0x3e967
movq 0x20(%rbx), %rax
jmp 0x3e9aa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e801
testq %rax, %rax
jne 0x3e9aa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a93
movq %rax, %rbx
movb (%rax), %al
movzbl %al, %eax
leaq 0x10d9bf(%rip), %rcx    # 0x14c330
cmpb $0x0, (%rax,%rcx)
jne 0x3e984
leaq 0x10d9f2(%rip), %rcx    # 0x14c370
cmpb $0x1, (%rax,%rcx)
jne 0x3e996
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3e801
xorl %eax, %eax
cmpq 0x2150(%r14), %rbx
leaq 0xcb8fb(%rip), %rcx     # 0x10a2a1
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_new_type_1
s7_int s7_new_type_1(s7_scheme *sc,
                        const char *name,
                        char *(*print)(s7_scheme *sc, void *value),
                        void (*gc_free)(void *value),
                        bool (*equal)(void *val1, void *val2),
                        void (*mark)(void *val),
                        s7_pointer (*ref)(s7_scheme *sc, s7_pointer obj, s7_pointer args), /* ignored */
                        s7_pointer (*set)(s7_scheme *sc, s7_pointer obj, s7_pointer args)) /* ignored */
                {
                    s7_int tag;
                    tag = s7_make_c_type(sc, name);
                    if (gc_free) sc->c_object_types[tag]->free = gc_free;
                    if (print) sc->c_object_types[tag]->print = print;
                    if (equal) sc->c_object_types[tag]->equal = equal;
                    if (mark) sc->c_object_types[tag]->mark = mark;
                    return(tag);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
callq 0x3ee94
testq %r13, %r13
je 0x3f198
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r13, 0x28(%rcx)
testq %r12, %r12
je 0x3f1ac
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r12, 0x40(%rcx)
testq %r15, %r15
je 0x3f1c0
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r15, 0x38(%rcx)
testq %rbx, %rbx
je 0x3f1d4
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %rbx, 0x30(%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_c_object_value_checked
void *s7_c_object_value_checked(s7_pointer obj, s7_int type)
                {
                    if ((is_c_object(obj)) &&
                            (c_object_type(obj) == type))
                        return(c_object_value(obj));
                    return(NULL);
                }

// Assembly:
cmpb $0x14, (%rdi)
jne 0x3f1f3
cmpq %rsi, 0x8(%rdi)
jne 0x3f1f3
movq 0x10(%rdi), %rax
retq
xorl %eax, %eax
retq