LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
andq 0x8(%rcx), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x37c4b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0x37c39
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0x2f770
testb $0x1, %al
jne 0x37c2b
jmp 0x37c37
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x37c5c
jmp 0x37c39
jmp 0x37c3b
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x37bf6
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_map_byte_vector
static s7_int hash_map_byte_vector(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (byte_vector_length(key) == 0)
                        return(0);
                    if (byte_vector_length(key) == 1)
                        return((s7_int)byte_vector(key, 0));
                    return(byte_vector_length(key) + byte_vector(key, 0) + byte_vector(key, 1));
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x37e26
movq $0x0, -0x8(%rsp)
jmp 0x37e72
movq -0x20(%rsp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x37e45
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
movq %rax, -0x8(%rsp)
jmp 0x37e72
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movzbl (%rcx), %ecx
addq %rcx, %rax
movq -0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movzbl 0x1(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x37ef8
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1ea7f9(%rip), %rax    # 0x2226d0
testb $0x1, (%rax,%rcx)
jne 0x37ef8
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x37f0b
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x38028
movq 0x18(%rsp), %rax
cmpq $0x1, 0x8(%rax)
je 0x37f52
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1ea7a0(%rip), %rax    # 0x2226d0
testb $0x1, (%rax,%rcx)
jne 0x37f52
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x37f90
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rdx
callq *%rax
movq %rax, 0x30(%rsp)
jmp 0x38028
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rdx
callq *%rax
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_map_int_vector
static s7_int hash_map_int_vector(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (vector_length(key) == 0)
                        return(0);
                    if (vector_length(key) == 1)
                        return(s7_int_abs(int_vector(key, 0)));
                    return(vector_length(key) + s7_int_abs(int_vector(key, 0)) + s7_int_abs(int_vector(key, 1)));
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x38069
movq $0x0, -0x8(%rsp)
jmp 0x38162
movq -0x20(%rsp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x380bf
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
jl 0x3809a
movq -0x28(%rsp), %rax
movq %rax, -0x58(%rsp)
jmp 0x380a6
xorl %eax, %eax
subq -0x28(%rsp), %rax
movq %rax, -0x58(%rsp)
movq -0x58(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x38162
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rsp)
cmpq $0x0, -0x38(%rsp)
jl 0x380f2
movq -0x38(%rsp), %rax
movq %rax, -0x68(%rsp)
jmp 0x380fe
xorl %eax, %eax
subq -0x38(%rsp), %rax
movq %rax, -0x68(%rsp)
movq -0x60(%rsp), %rax
movq -0x68(%rsp), %rcx
movq %rcx, -0x40(%rsp)
addq -0x40(%rsp), %rax
movq %rax, -0x70(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rsp)
cmpq $0x0, -0x48(%rsp)
jl 0x3813d
movq -0x48(%rsp), %rax
movq %rax, -0x78(%rsp)
jmp 0x38149
xorl %eax, %eax
subq -0x48(%rsp), %rax
movq %rax, -0x78(%rsp)
movq -0x70(%rsp), %rax
movq -0x78(%rsp), %rcx
movq %rcx, -0x50(%rsp)
addq -0x50(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3819a
movq $0x0, 0x30(%rsp)
jmp 0x38212
movq 0x18(%rsp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x381bf
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
callq 0xd93b0
movq %rax, 0x30(%rsp)
jmp 0x38212
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
callq 0xd93b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm0
callq 0xd93b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_map_ratio_eq
static s7_int hash_map_ratio_eq(s7_scheme *sc, s7_pointer table, s7_pointer y)
                {
                    s7_double x;
                    x = fraction(y);
                    if (x < 0.0)
                        return(s7_round(-x));
                    return(s7_round(x));
                }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rax, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x3880d
movsd 0x20(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x112c0
cvttsd2si %xmm0, %rax
movq %rax, 0x40(%rsp)
jmp 0x38822
movsd 0x20(%rsp), %xmm0
callq 0x112c0
cvttsd2si %xmm0, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rcx
andq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x38a4b
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x38a39
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x38a39
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x38a5c
jmp 0x38a3b
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x389fe
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
movq 0x20(%rsp), %rcx
andq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x38b03
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x38af1
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x38b14
jmp 0x38af3
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x38ace
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x38d69
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
andq -0x30(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rsp)
cmpq $0x0, -0x40(%rsp)
je 0x38d67
movq -0x40(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x38(%rsp), %rax
jne 0x38d55
movq -0x40(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x38d7a
jmp 0x38d57
movq -0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rsp)
jmp 0x38d2e
jmp 0x38d69
movq -0x10(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x38df2
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0xd93b0
andq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rdx
movsd 0x10(%rsp), %xmm0
callq 0xd94a0
movq %rax, 0x30(%rsp)
jmp 0x38e03
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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 %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rsp), %rcx
sarq $0x8, %rcx
movq -0x18(%rsp), %rdx
andq 0x8(%rdx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0x38e78
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x38e66
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x38e89
jmp 0x38e68
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x38e43
movq -0x10(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x38eb3
jmp 0x38f18
movq 0x18(%rsp), %rax
movzbl 0x8(%rax), %eax
movq 0x20(%rsp), %rcx
andq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x38f16
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x38f04
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x38f29
jmp 0x38f06
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x38ee1
jmp 0x38f18
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
movb %sil, %al
movq %rdi, -0x8(%rsp)
movb %al, -0x9(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movzbl -0x9(%rsp), %ecx
movl %ecx, %edx
leaq 0x1e2a3d(%rip), %rcx    # 0x21bb20
cmpq (%rcx,%rdx,8), %rax
je 0x3913c
movq -0x8(%rsp), %rax
leaq -0x1d65(%rip), %rcx     # 0x37390
cmpq %rcx, 0x18(%rax)
jne 0x39118
movzbl -0x9(%rsp), %eax
movl %eax, %ecx
leaq 0x1e2a17(%rip), %rax    # 0x21bb20
movq (%rax,%rcx,8), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3913a
movq -0x8(%rsp), %rax
leaq -0x14b4(%rip), %rcx     # 0x37c70
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
orq $0x20000000, %rcx       # imm = 0x20000000
movq %rcx, (%rax)
jmp 0x3913c
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x98, %rsp
movb %r9b, %al
movq 0xa0(%rsp), %r9
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq 0x90(%rsp), %rdi
callq 0x148a0
movq %rax, 0x60(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x48(%rsp)
movb 0x6f(%rsp), %al
movb %al, 0x27(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x90(%rsp), %rdi
callq 0x39630
movb 0x27(%rsp), %r9b
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x50(%rsp), %r11
movq 0x58(%rsp), %r10
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x39420
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x4000, %ecx           # imm = 0x4000
movw %cx, 0x6(%rax)
movq 0x60(%rsp), %rax
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: alloc_permanent_function
static c_proc_t *alloc_permanent_function(s7_scheme *sc)
                {
#define ALLOC_FUNCTION_SIZE 128

                    if (sc->alloc_function_k == ALLOC_FUNCTION_SIZE)
                    {
                        sc->alloc_function_cells = (c_proc_t *)malloc(ALLOC_FUNCTION_SIZE * sizeof(c_proc_t));
                        sc->alloc_function_k = 0;
                    }
                    return(&(sc->alloc_function_cells[sc->alloc_function_k++]));
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x80, 0x7f4(%rax)
jne 0x3966b
movl $0x3400, %edi           # imm = 0x3400
callq 0x9480
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x808(%rax)
movq (%rsp), %rax
movl $0x0, 0x7f4(%rax)
movq (%rsp), %rax
movq 0x808(%rax), %rax
movq (%rsp), %rdx
movl 0x7f4(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x7f4(%rdx)
movl %ecx, %ecx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %r9b, %al
movq 0x58(%rsp), %r9
movq 0x50(%rsp), %r9
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movb 0x1f(%rsp), %r9b
movq 0x50(%rsp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x39300
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
orq $0x200000, %rcx         # imm = 0x200000
movq %rcx, (%rax)
cmpq $0x0, 0x58(%rsp)
je 0x397b5
movq 0x58(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %r9b, %al
movq 0x50(%rsp), %r9
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movb 0x1f(%rsp), %r9b
movq 0x50(%rsp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x39300
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb400
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x10090
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movb %r9b, %al
movq 0x68(%rsp), %r9
movq 0x60(%rsp), %r9
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movb 0x2f(%rsp), %r9b
movq 0x60(%rsp), %r10
movq 0x68(%rsp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x39720
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xb400
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x10090
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x60(%rax)
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %r9b, %al
movq 0x58(%rsp), %r9
movq 0x50(%rsp), %r9
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movb 0x1f(%rsp), %r9b
movq 0x50(%rsp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x39300
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x39c13
movq 0x58(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb400
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x10090
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
jne 0x3a161
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x3a15f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xc3980
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3a134
jmp 0x3a161
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x39d50
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
orq $0x200000, %rcx         # imm = 0x200000
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x2d950
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x60(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %r9b, %al
movq 0x50(%rsp), %r9
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x3a2a7
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x3a170
movq %rax, 0x10(%rsp)
jmp 0x3a2ca
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x39d50
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb400
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x10090
cmpq $0x0, 0x50(%rsp)
je 0x3a318
movq 0x50(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3a453
movq 0x10(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x3a40c
movq $0x0, 0x20(%rsp)
jmp 0x3a4ec
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x3a43f
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3a4ec
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb3a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2f, %eax
jge 0x3a46d
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x3a481
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3a4ec
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x3a49e
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3a4ec
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x16c0(%rax), %rdx
callq 0x3a500
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3a4e3
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
jne 0x3a4e3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3a4ec
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1dbf1c(%rip), %rax    # 0x216440
testb $0x1, (%rax,%rcx)
je 0x3a5b9
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x3a5b9
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x101d0
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x3a59c
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x3a59c
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
callq 0x101d0
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x3a5b7
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3a5c2
jmp 0x3a5b9
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x3a601
movq $0x0, 0x20(%rsp)
jmp 0x3a64c
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3a642
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
orq $0x20000000, %rcx       # imm = 0x20000000
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x10340
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x3a68b
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3a73c
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3a6d2
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x3a3d0
cmpq $0x0, %rax
je 0x3a6c0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x3a3d0
movq %rax, 0x10(%rsp)
jmp 0x3a73c
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xb3a0
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1e177e(%rip), %rax    # 0x21be60
testb $0x1, (%rax,%rcx)
jne 0x3a6fe
movq (%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1e17a8(%rip), %rax    # 0x21bea0
testb $0x1, (%rax,%rcx)
je 0x3a713
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x3a3d0
movq %rax, 0x10(%rsp)
jmp 0x3a73c
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x2150(%rcx), %rax
jne 0x3a733
leaq 0x1a765d(%rip), %rax    # 0x1e1d89
movq %rax, 0x10(%rsp)
jmp 0x3a73c
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3b4a0
movq %rax, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x3bbc4
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movq (%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x20(%rsp)
je 0x3bbe9
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movq (%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, 0x10(%rsp)
je 0x3bc0e
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movq (%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x38(%rax)
cmpq $0x0, 0x8(%rsp)
je 0x3bc33
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movq (%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x14, %eax
jne 0x3bc87
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x3bc87
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x3bc90
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x3bcdc
movq 0x30(%rsp), %rdi
callq 0xc670
movq 0x30(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x150(%rcx), %rax
jne 0x3bd62
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3bd6c
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x30(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x768(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x11230
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
jne 0x3be7e
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x3be7e
movq -0x18(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x150(%rcx), %rax
jne 0x3be66
movq -0x8(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x3be70
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)