LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_simple_int_vector
static inline s7_pointer make_simple_int_vector(s7_scheme *sc, s7_int len) /* len >= 0 and < max */
                {
                    s7_pointer x;
                    block_t *b;
                    new_cell(sc, x, T_INT_VECTOR | T_SAFE_PROCEDURE);
                    vector_length(x) = len;
                    b = mallocate_vector(sc, len * sizeof(s7_int));
                    vector_block(x) = b;
                    int_vector_ints(x) = (s7_int *)block_data(b);
                    vector_set_dimension_info(x, NULL);
                    vector_getter(x) = int_vector_getter;
                    vector_setter(x) = int_vector_setter;
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x2fe1e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200016, (%r15)       # imm = 0x200016
movq %r14, 0x8(%r15)
shlq $0x3, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e974
movq %rax, 0x18(%r15)
movq (%rax), %rcx
movq %rcx, 0x10(%r15)
andq $0x0, 0x20(%rax)
leaq 0x4b01f(%rip), %rax     # 0x7ae7d
movq %rax, 0x20(%r15)
leaq 0x4b07a(%rip), %rax     # 0x7aee3
movq %rax, 0x28(%r15)
movq 0x740(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x2feaf
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200018, (%r15)       # imm = 0x200018
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9037
movq %rax, 0x18(%r15)
movq (%rax), %rcx
movq %rcx, 0x10(%r15)
movq %r14, 0x8(%r15)
andq $0x0, 0x20(%rax)
leaq 0x4b02d(%rip), %rax     # 0x7af18
movq %rax, 0x20(%r15)
leaq 0x4b036(%rip), %rax     # 0x7af2c
movq %rax, 0x28(%r15)
movq 0x740(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x9037
movq %rax, %rbx
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2ff50
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x2ff50
movq %r14, %rsi
cmpl $0x6, %eax
jl 0x2ff4b
callq 0x7ae55
jmp 0x2ff50
callq 0x78377
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r13
movq %rdi, %r14
movq 0x20(%rsi), %rax
movzbl (%rdx), %ecx
callq *(%rax,%rcx,8)
movq %rax, %r12
movq 0x8(%r13), %r15
andq %rax, %r15
shlq $0x3, %r15
addq 0x10(%r13), %r15
leaq 0xf1858(%rip), %r13     # 0x121d20
movq (%r15), %r15
testq %r15, %r15
je 0x304f3
cmpq %r12, 0x10(%r15)
jne 0x304ed
movq (%r15), %rsi
movzbl (%rsi), %eax
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq *(%r13,%rax,8)
testb %al, %al
jne 0x304fa
addq $0x18, %r15
jmp 0x304c8
movq 0x490(%r14), %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x30626
movq %rdx, %r12
movq %rsi, %r14
movq 0x10(%rdx), %rcx
movq (%rcx), %rdx
movzbl (%rdx), %eax
leaq 0xf15b9(%rip), %rsi     # 0x121b80
cmpb $0x0, (%rax,%rsi)
jne 0x30628
movq (%rdx), %rax
btl $0x1e, %eax
jb 0x30628
movq %rdi, %r15
cmpq $0x1, %rbx
je 0x30635
movq 0x8(%rcx), %rcx
movzbl (%rcx), %edi
cmpb $0x0, (%rdi,%rsi)
jne 0x30635
testb $0x40, 0x3(%rcx)
jne 0x30635
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 0x30628
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_O2/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, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rdx
movzbl (%rdx), %ecx
leaq 0xf138b(%rip), %r13     # 0x121b80
cmpb $0x0, (%rcx,%r13)
jne 0x30805
movq (%rdx), %rax
btl $0x1e, %eax
jae 0x30821
cmpb $0x1, %cl
jne 0x30839
movq 0x8(%rdx), %rdx
movzbl (%rdx), %eax
cmpb $0x0, (%rax,%r13)
jne 0x30839
movq (%rdx), %rax
btl $0x1e, %eax
jb 0x30839
movq 0x20(%r14), %rcx
movzbl %al, %eax
movq %r15, %rdi
movq %r14, %rsi
callq *(%rcx,%rax,8)
movq %rax, %r12
incq %r12
jmp 0x3083c
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x3088e
movq 0x8(%rax), %rdx
movzbl (%rdx), %ecx
cmpb $0x0, (%rcx,%r13)
jne 0x3085c
movq (%rdx), %rax
btl $0x1e, %eax
jae 0x30878
cmpb $0x1, %cl
jne 0x3088e
movq 0x8(%rdx), %rdx
movzbl (%rdx), %eax
cmpb $0x0, (%rax,%r13)
jne 0x3088e
movq (%rdx), %rax
btl $0x1e, %eax
jb 0x3088e
movq 0x20(%r14), %rcx
movzbl %al, %eax
movq %r15, %rdi
movq %r14, %rsi
callq *(%rcx,%rax,8)
addq %rax, %r12
incq %r12
xorl %eax, %eax
cmpb $0x1, (%rbx)
jne 0x308a3
cmpl $0x7, %eax
ja 0x308a3
movq 0x10(%rbx), %rbx
incq %rax
jmp 0x30890
shlq $0x3, %r12
orq %rax, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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
shlq $0x3, %rax
addq 0x10(%r15), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x30a3d
movq (%rax), %rcx
cmpb $0x9, (%rcx)
jne 0x30a37
movq 0x8(%rcx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x30a44
addq $0x18, %rax
jmp 0x30a1d
movq 0x490(%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
shlq $0x3, %rax
addq 0x10(%r15), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x30a81
cmpq %rbx, (%rax)
je 0x30a88
addq $0x18, %rax
jmp 0x30a6e
movq 0x490(%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
cmpb $0x13, (%rdx)
jne 0x30b35
movq %rdx, %r12
movq %rsi, %rbp
movq 0x8(%rdx), %r14
movq 0x10(%rdx), %r13
movq 0x18(%rdx), %r15
testq %r15, %r15
jne 0x30acf
movq %r13, %rdi
movq %r14, %rsi
callq 0x8dae
movq %rax, %r15
movq %rax, 0x18(%r12)
movq 0x8(%rbp), %r12
andq %r15, %r12
shlq $0x3, %r12
addq 0x10(%rbp), %r12
cmpq $0x9, %r14
jge 0x30b03
movq (%r12), %r12
testq %r12, %r12
je 0x30b35
movq (%r12), %rax
cmpq 0x18(%rax), %r15
jne 0x30afd
cmpq 0x8(%rax), %r14
je 0x30b3c
addq $0x18, %r12
jmp 0x30ae4
movq (%r12), %r12
testq %r12, %r12
je 0x30b35
movq (%r12), %rax
cmpq 0x18(%rax), %r15
jne 0x30b2f
cmpq 0x8(%rax), %r14
jne 0x30b2f
movq 0x10(%rax), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0x70ab0
testb %al, %al
jne 0x30b3c
addq $0x18, %r12
jmp 0x30b03
movq 0x490(%rbx), %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x30b7d
movq 0x8(%rdx), %rcx
movq 0x8(%rsi), %rax
andq %rcx, %rax
shlq $0x3, %rax
addq 0x10(%rsi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x30b7d
movq (%rax), %rdx
cmpq %rcx, 0x8(%rdx)
je 0x30b84
addq $0x18, %rax
jmp 0x30b66
movq 0x490(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
cmpb $0xd, (%rdx)
jne 0x30bcd
movq %rsi, %rbx
movq 0x8(%rsi), %r15
movsd 0x8(%rdx), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x7b4a8
andq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7b4df
movq 0x490(%r14), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rax
sarq $0x8, %rax
andq 0x8(%rsi), %rax
shlq $0x3, %rax
addq 0x10(%rsi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x30c04
cmpq %rdx, (%rax)
je 0x30c0b
addq $0x18, %rax
jmp 0x30bf1
movq 0x490(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: hash_char
static hash_entry_t *hash_char(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (s7_is_character(key))
                    {
                        /* return(hash_eq(sc, table, key));
                         *   but I think if we get here at all, we have to be using default_hash_checks|maps -- see hash_symbol above.
                         */
                        hash_entry_t *x;
                        s7_int loc;
                        loc = character(key) & hash_table_mask(table);
                        for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                            if (key == hash_entry_key(x))
                                return(x);
                    }
                    return(sc->unentry);
                }

// Assembly:
cmpb $0x8, (%rdx)
jne 0x30c32
movzbl 0x8(%rdx), %eax
andl 0x8(%rsi), %eax
shll $0x3, %eax
addq 0x10(%rsi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x30c32
cmpq %rdx, (%rax)
je 0x30c39
addq $0x18, %rax
jmp 0x30c1f
movq 0x490(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: hash_table_set_checker
static void hash_table_set_checker(s7_pointer table, uint8_t typ)
                {
                    if (hash_table_checker(table) != default_hash_checks[typ])
                    {
                        if (hash_table_checker(table) == hash_empty)
                            hash_table_checker(table) = default_hash_checks[typ];
                        else
                        {
                            hash_table_checker(table) = hash_equal;
                            hash_set_chosen(table);
                        }
                    }
                }

// Assembly:
movq 0x18(%rdi), %rax
movl %esi, %ecx
leaq 0xea3a9(%rip), %rdx     # 0x11aff0
movq (%rdx,%rcx,8), %rcx
cmpq %rcx, %rax
je 0x30c6b
leaq -0xcfc(%rip), %rdx      # 0x2ff5b
cmpq %rdx, %rax
je 0x30c6c
leaq -0x75c(%rip), %rax      # 0x30507
movq %rax, 0x18(%rdi)
orb $0x20, 0x3(%rdi)
retq
movq %rcx, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r12
movq 0x28(%rsi), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x1(%r12), %rsi
leaq 0x3(,%r12,4), %rbp
shlq $0x5, %rsi
callq 0x2ff1e
movq %rax, %r15
movq (%rax), %r13
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
cmpq %r12, %rcx
jg 0x30cf2
movq (%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x30ced
movq 0x18(%rdx), %rsi
movq 0x10(%rdx), %rdi
andq %rbp, %rdi
movq (%r13,%rdi,8), %r8
movq %r8, 0x18(%rdx)
movq %rdx, (%r13,%rdi,8)
movq %rsi, %rdx
jmp 0x30cca
incq %rcx
jmp 0x30cc1
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x9439
movq %r15, 0x28(%rbx)
movq %r13, 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_O2/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 0xd35f
movq %rax, %rbx
movl 0x7f4(%r14), %ecx
cmpl $0x80, %ecx
jne 0x30d80
movl $0x3400, %edi           # imm = 0x3400
callq 0x8480
movq %rax, 0x808(%r14)
xorl %ecx, %ecx
jmp 0x30d87
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 0x30dd9
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_O2/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 0x30d36
orb $0x20, 0x2(%rax)
testq %rbx, %rbx
je 0x30f7b
movq 0x8(%rax), %rcx
movq %rbx, 0x38(%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x30d36
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x94d4
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xb123
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x30f52
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x94d4
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xb123
movq 0x8(%r15), %rax
andq $0x0, 0x60(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x30d36
movq %rax, %r15
testq %r12, %r12
je 0x31152
movq 0x8(%r15), %rax
movq %r12, 0x38(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x94d4
movq %rax, %r14
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xb123
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x30d36
movq %rax, %r15
movabsq $0x400000000000202e, %rax # imm = 0x400000000000202E
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x94d4
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xb123
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x31411
pushq %rbx
movq 0x8(%rdi), %rbx
addq $0x60, %rbx
movq (%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0x31410
movq 0x8(%rbx), %rdi
callq 0x72838
addq $0x10, %rbx
jmp 0x313f9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x311ef
movq %rax, %r14
orb $0x20, 0x2(%rax)
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x2c2e2
movq 0x8(%r14), %rcx
movq %rax, 0x60(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x31473
callq 0x31412
jmp 0x31478
callq 0x311ef
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x94d4
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xb123
testq %r12, %r12
je 0x314a8
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_O2/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 0x314fc
testb $-0x80, 0x6(%rsi)
jne 0x31530
movq 0x8(%rsi), %rax
testb $0x20, 0x3(%rax)
jne 0x31534
movq %rbx, %rdi
callq 0x94b4
movq %rax, %rsi
movb (%rax), %al
cmpb $0x2e, %al
jb 0x3150a
movq 0x8(%rsi), %rsi
addq $0x10, %rsi
jmp 0x3153c
cmpb $0x9, %al
jne 0x31514
addq $0x20, %rsi
jmp 0x3153c
movq 0x16c0(%rbx), %rdx
movq %rbx, %rdi
callq 0x31541
testq %rax, %rax
je 0x31530
movq %rax, %rsi
cmpb $0x13, (%rax)
je 0x31504
xorl %eax, %eax
jmp 0x3153f
movq 0x20(%rax), %rsi
addq $0x18, %rsi
movq (%rsi), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe43c5(%rip), %rcx     # 0x115910
cmpb $0x1, (%rax,%rcx)
jne 0x3157c
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rsi), %r15
cmpb $0x1c, (%r15)
jne 0x31598
movq %rdx, %rbx
movq %rdi, %r14
movq %rdx, %rsi
movq %r15, %rdx
callq 0xb1df
cmpb $0x20, (%rax)
jne 0x3157f
movq 0x10(%rax), %rax
jmp 0x3159a
xorl %eax, %eax
retq
movq 0x10(%r15), %rdx
cmpb $0x1c, (%rdx)
jne 0x31598
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb1df
cmpb $0x20, (%rax)
je 0x31576
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x315d6
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0xa, (%rsi)
jne 0x315d8
movq 0x8(%r14), %rax
orq $0x20000000, (%rax)     # imm = 0x20000000
movq %rbx, %rdi
callq 0xb284
movq 0x8(%r14), %rcx
movq 0x20(%rcx), %rcx
movq %rax, 0x18(%rcx)
jmp 0x315d8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x31600
cmpl $0x9, %eax
jne 0x31620
movq 0x20(%rbx), %rax
jmp 0x31663
movq %r14, %rdi
movq %rbx, %rsi
callq 0x314d5
testq %rax, %rax
jne 0x31663
movq %r14, %rdi
movq %rbx, %rsi
callq 0x94b4
movq %rax, %rbx
movb (%rax), %al
movzbl %al, %eax
leaq 0xe9d06(%rip), %rcx     # 0x11b330
cmpb $0x0, (%rax,%rcx)
jne 0x3163d
leaq 0xe9d39(%rip), %rcx     # 0x11b370
cmpb $0x1, (%rax,%rcx)
jne 0x3164f
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x314d5
xorl %eax, %eax
cmpq 0x2150(%r14), %rbx
leaq 0xa4be2(%rip), %rcx     # 0xd6241
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x31adf
testq %r13, %r13
je 0x31de2
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r13, 0x28(%rcx)
testq %r12, %r12
je 0x31df6
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r12, 0x40(%rcx)
testq %r15, %r15
je 0x31e0a
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r15, 0x38(%rcx)
testq %rbx, %rbx
je 0x31e1e
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_O2/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 0x31e3d
cmpq %rsi, 0x8(%rdi)
jne 0x31e3d
movq 0x10(%rdi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_make_c_object_with_let
s7_pointer s7_make_c_object_with_let(s7_scheme *sc, s7_int type, void *value, s7_pointer let)
                {
                    s7_pointer x;
                    new_cell(sc, x, sc->c_object_types[type]->outer_type);

                    /* c_object_info(x) = &(sc->c_object_types[type]); */
                    /* that won't work because c_object_types can move when it is realloc'd and the old stuff is freed by realloc
                     *   and since we're checking (for example) ref_2 existence as not null, we can't use a table of c_object_t's!
                     */
                    c_object_type(x) = type;
                    c_object_value(x) = value;
                    c_object_set_let(x, (let == sc->rootlet) ? sc->nil : let);
                    c_object_mark(x) = sc->c_object_types[type]->mark;
                    add_c_object(sc, x);
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x31e74
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq 0x8d8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rax
movq %rax, (%r12)
movq %r14, 0x8(%r12)
movq %r13, 0x10(%r12)
cmpq %r15, 0x150(%rbx)
jne 0x31eb0
movq 0x110(%rbx), %r15
movq %r15, 0x18(%r12)
movq 0x8d8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%r12)
movq 0x768(%rbx), %rdi
movq %r12, %rsi
callq 0xb999
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_c_object_set_let
s7_pointer s7_c_object_set_let(s7_scheme *sc, s7_pointer obj, s7_pointer e)
                {
                    if ((!is_immutable(obj)) &&
                            (is_let(e)))
                        c_object_set_let(obj, (e == sc->rootlet) ? sc->nil : e);
                    return(e);
                }

// Assembly:
movq %rdx, %rax
testb $0x1, 0x3(%rsi)
jne 0x31f1b
cmpb $0x1c, (%rax)
jne 0x31f1b
movq %rax, %rcx
cmpq %rax, 0x150(%rdi)
jne 0x31f17
movq 0x110(%rdi), %rcx
movq %rcx, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_dilambda
s7_pointer s7_dilambda(s7_scheme *sc,
                        const char *name,
                        s7_pointer (*getter)(s7_scheme *sc, s7_pointer args),
                        s7_int get_req_args, s7_int get_opt_args,
                        s7_pointer (*setter)(s7_scheme *sc, s7_pointer args),
                        s7_int set_req_args, s7_int set_opt_args,
                        const char *documentation)
                {
                    s7_pointer get_func, set_func;
                    char *internal_set_name;
                    s7_int len;

                    if (!name) return(sc->F);
                    len = 16 + safe_strlen(name);
                    internal_set_name = (char *)malloc(len);
                    internal_set_name[0] = '\0';
                    catstrs_direct(internal_set_name, "[set-", name, "]", NULL);

                    get_func = s7_make_safe_function(sc, name, getter, get_req_args, get_opt_args, false, documentation);
                    s7_define(sc, sc->nil, make_symbol(sc, name), get_func);
                    set_func = s7_make_function(sc, internal_set_name, setter, set_req_args, set_opt_args, false, documentation);
                    c_function_set_setter(get_func, set_func);

                    return(get_func);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x31ff2
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rsi, %rdi
movq %r9, 0x10(%rsp)
callq 0x8d06
leaq 0x10(%rax), %rdi
callq 0x8480
movq %rax, %rbp
movb $0x0, (%rax)
leaq 0xa432e(%rip), %rsi     # 0xd6293
leaq 0xa4393(%rip), %rcx     # 0xd62ff
movq %rax, %rdi
movq %r13, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xb3a5
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x30f3d
movq %rax, %rbx
movq 0x110(%r14), %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0x94d4
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xb123
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %r8
xorl %r9d, %r9d
callq 0x30d36
movq 0x8(%rbx), %rcx
movq %rax, 0x30(%rcx)
jmp 0x31ff9
movq 0x120(%r14), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_typed_dilambda
s7_pointer s7_typed_dilambda(s7_scheme *sc,
                        const char *name,
                        s7_pointer (*getter)(s7_scheme *sc, s7_pointer args),
                        s7_int get_req_args, s7_int get_opt_args,
                        s7_pointer (*setter)(s7_scheme *sc, s7_pointer args),
                        s7_int set_req_args, s7_int set_opt_args,
                        const char *documentation,
                        s7_pointer get_sig, s7_pointer set_sig)
                {
                    s7_pointer get_func, set_func;
                    get_func = s7_dilambda(sc, name, getter, get_req_args, get_opt_args, setter, set_req_args, set_opt_args, documentation);
                    set_func = c_function_setter(get_func);
                    if (get_sig) c_function_signature(get_func) = get_sig;
                    if (set_sig) c_function_signature(set_func) = set_sig;
                    return(get_func);
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r14
movaps 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x31f1c
movq 0x8(%rax), %rcx
testq %r14, %r14
je 0x32041
movq %r14, 0x38(%rcx)
testq %rbx, %rbx
je 0x32052
movq 0x30(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, 0x38(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: slot_set_setter
static void slot_set_setter(s7_pointer p, s7_pointer val)
    {
        if ((type(val) == T_C_FUNCTION) &&
                (c_function_has_bool_setter(val)))
            slot_set_setter_1(p, c_function_bool_setter(val));
        else slot_set_setter_1(p, val);
    }

// Assembly:
cmpb $0x30, (%rsi)
jne 0x32b41
testb $0x2, 0x6(%rsi)
je 0x32b41
movq 0x8(%rsi), %rax
movq 0x50(%rax), %rsi
movq %rsi, 0x28(%rdi)
retq