LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_append
s7_pointer s7_append(s7_scheme *sc, s7_pointer a, s7_pointer b)
                {
                    s7_pointer p, tp, np;
                    if (is_null(a)) return(b);

                    tp = cons(sc, car(a), sc->nil);
                    sc->y = tp;
                    for (p = cdr(a), np = tp; is_pair(p); p = cdr(p), np = cdr(np))
                        set_cdr(np, cons(sc, car(p), sc->nil));
                    set_cdr(np, b);
                    sc->y = sc->nil;

                    return(tp);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x110(%rdi), %r13
cmpq %rsi, %r13
je 0x3c284
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, (%rsp)
movq 0x8(%rsi), %rbp
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3c1d2
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %rbp, 0x8(%r15)
movq %r13, 0x10(%r15)
movq %r15, 0x4e8(%r14)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %r15, %rax
jne 0x3c26c
movq %r15, %r13
movq 0x8(%r12), %rbp
movq 0x90(%r14), %rax
movq 0x110(%r14), %rbx
cmpq 0x98(%r14), %rax
ja 0x3c234
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %rax, %r13
je 0x3c210
movq (%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x110(%r14), %rax
movq %rax, 0x4e8(%r14)
jmp 0x3c287
movq %rdx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_is_proper_list
bool s7_is_proper_list(s7_scheme *sc, s7_pointer lst)
                {
                    /* #t if () or undotted/non-circular pair */
                    s7_pointer slow, fast;

                    fast = lst;
                    slow = lst;
                    while (true)
                    {
                        if (!is_pair(fast))
                            return(is_null(fast)); /* else it's an improper list */
                        LOOP_4(fast = cdr(fast); if (!is_pair(fast)) return(is_null(fast)));
                        fast = cdr(fast);
                        slow = cdr(slow);
                        if (fast == slow) return(false);
                    }
                    return(true);
                }

// Assembly:
movq %rsi, %rax
cmpb $0x1, (%rax)
jne 0x3c337
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x3c337
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x3c337
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x3c337
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x3c337
movq 0x10(%rax), %rax
movq 0x10(%rsi), %rsi
cmpq %rsi, %rax
jne 0x3c2fe
xorl %eax, %eax
retq
cmpq 0x110(%rdi), %rax
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_list
s7_pointer s7_list(s7_scheme *sc, s7_int num_values, ...)
                {
                    s7_int i;
                    va_list ap;
                    s7_pointer p;

                    if (num_values == 0)
                        return(sc->nil);

                    sc->w = make_list(sc, num_values, sc->nil);
                    va_start(ap, num_values);
                    for (i = 0, p = sc->w; i < num_values; i++, p = cdr(p))
                        set_car(p, va_arg(ap, s7_pointer));
                    va_end(ap);

                    if (sc->safety > NO_SAFETY)
                        check_list_validity(sc, "s7_list", sc->w);

                    p = sc->w;
                    sc->w = sc->nil;
                    return(p);
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x3c4e1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x3c5a3
movq %rsi, %r14
movq 0x110(%rbx), %rdx
movq %rbx, %rdi
callq 0x3c5b5
movq %rax, 0x4d8(%rbx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testq %r14, %r14
jle 0x3c56c
leaq 0x4d8(%rbx), %rax
movl (%rsp), %ecx
cmpl $0x28, %ecx
ja 0x3c54b
movl %ecx, %edx
addq 0x10(%rsp), %rdx
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3c559
movq 0x8(%rsp), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rsp)
movq (%rax), %rax
movq (%rdx), %rdx
movq %rdx, 0x8(%rax)
addq $0x10, %rax
decq %r14
jne 0x3c537
cmpq $0x0, 0x6a0(%rbx)
jle 0x3c58c
movq 0x4d8(%rbx), %rdx
leaq 0xd6b80(%rip), %rsi     # 0x113104
movq %rbx, %rdi
callq 0x3c989
movq 0x4d8(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
jmp 0x3c5aa
movq 0x110(%rbx), %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: check_list_validity
static void check_list_validity(s7_scheme *sc, const char *caller, s7_pointer lst)
                {
                    s7_pointer p;
                    int32_t i;
                    for (i = 1, p = lst; is_pair(p); p = cdr(p), i++)
                        if (!s7_is_valid(sc, car(p)))
                            s7_warn(sc, 256, "bad arg (#%d) to %s: %p\n", i, caller, car(p));
                }

// Assembly:
cmpb $0x1, (%rdx)
jne 0x3c9f4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebp
leaq 0xe35f0(%rip), %r12     # 0x11ff9e
movq 0x8(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x39e82
testb %al, %al
jne 0x3c9db
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %r12, %rdx
movl %ebp, %ecx
movq %r14, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0xfc3d
movq 0x10(%rbx), %rbx
incl %ebp
cmpb $0x1, (%rbx)
je 0x3c9ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_vector
s7_pointer s7_make_vector(s7_scheme *sc, s7_int len)
                {
                    s7_pointer v;
                    v = make_vector_1(sc, len, FILLED, T_VECTOR);
                    add_vector(sc, v);
                    return(v);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edx
movl $0x15, %ecx
callq 0x3ccdf
movq %rax, %rbx
movq 0x740(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x3ccc1
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_int_vector
s7_pointer s7_make_int_vector(s7_scheme *sc, s7_int len, s7_int dims, s7_int *dim_info)
                {
                    s7_pointer p;
                    p = make_vector_1(sc, len, FILLED, T_INT_VECTOR);
                    if (dim_info)
                    {
                        vector_set_dimension_info(p, make_vdims(sc, false, dims, dim_info));
                        add_multivector(sc, p);
                    }
                    else add_vector(sc, p);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
movl $0x1, %edx
movl $0x16, %ecx
callq 0x3ccdf
movq %rax, %rbx
testq %r15, %r15
je 0x3d279
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3d2c3
movq 0x18(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x790(%r14), %r14
jmp 0x3d280
movq 0x740(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x3d2a1
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_vdims
static vdims_t *make_vdims(s7_scheme *sc, bool elements_should_be_freed, s7_int dims, s7_int *dim_info)
                {
                    vdims_t *v;

                    if ((dims == 1) && (!elements_should_be_freed))
                        return(sc->wrap_only);

                    if (dims > 1)
                    {
                        s7_int i, offset = 1;
                        v = (vdims_t *)mallocate(sc, dims * 2 * sizeof(s7_int));
                        vdims_original(v) = sc->F;
                        vector_elements_should_be_freed(v) = elements_should_be_freed;
                        vdims_rank(v) = dims;
                        vdims_offsets(v) = (s7_int *)(vdims_dims(v) + dims);

                        for (i = 0; i < dims; i++)
                            vdims_dims(v)[i] = dim_info[i];
                        for (i = dims - 1; i >= 0; i--)
                        {
                            vdims_offsets(v)[i] = offset;
                            offset *= vdims_dims(v)[i];
                        }
                    }
                    else
                    {
                        v = (vdims_t *)mallocate_block(sc);
                        vdims_original(v) = sc->F;
                        vector_elements_should_be_freed(v) = elements_should_be_freed;
                        vdims_rank(v) = 1;
                        vdims_dims(v) = NULL;
                        vdims_offsets(v) = NULL;
                    }
                    return(v);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
cmpq $0x1, %rdx
setne %al
orb %bpl, %al
je 0x3d355
movq %rdx, %rbx
cmpq $0x2, %rdx
jl 0x3d35e
movq %rcx, %r15
movq %rbx, %rsi
shlq $0x4, %rsi
movq %r14, %rdi
callq 0xa305
movq 0x120(%r14), %rcx
movq %rcx, 0x20(%rax)
movb %bpl, 0xc(%rax)
movq %rbx, 0x10(%rax)
leaq (,%rbx,8), %rcx
addq (%rax), %rcx
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq (%rax), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0x3d31a
incq %rbx
movl $0x1, %ecx
movq 0x18(%rax), %rdx
movq %rcx, -0x10(%rdx,%rbx,8)
movq (%rax), %rdx
imulq -0x10(%rdx,%rbx,8), %rcx
decq %rbx
cmpq $0x1, %rbx
jg 0x3d335
jmp 0x3d3dd
movq 0x470(%r14), %rax
jmp 0x3d3dd
cmpq $0x0, 0x838(%r14)
jne 0x3d3a4
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x3d382
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r14), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r14)
movl $0x0, 0x8(%rax)
movq 0x120(%r14), %rcx
movq %rcx, 0x20(%rax)
movb %bpl, 0xc(%rax)
movq $0x1, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_float_vector
s7_pointer s7_make_float_vector(s7_scheme *sc, s7_int len, s7_int dims, s7_int *dim_info)
                {
                    s7_pointer p;
                    p = make_vector_1(sc, len, FILLED, T_FLOAT_VECTOR);
                    if (dim_info)
                    {
                        vector_set_dimension_info(p, make_vdims(sc, false, dims, dim_info));
                        add_multivector(sc, p);
                    }
                    else add_vector(sc, p);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
movl $0x1, %edx
movl $0x17, %ecx
callq 0x3ccdf
movq %rax, %rbx
testq %r15, %r15
je 0x3d431
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3d2c3
movq 0x18(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x790(%r14), %r14
jmp 0x3d438
movq 0x740(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x3d459
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_float_vector_wrapper
s7_pointer s7_make_float_vector_wrapper(s7_scheme *sc, s7_int len, s7_double *data, s7_int dims, s7_int *dim_info, bool free_data)
                {
                    /* this wraps up a C-allocated/freed double array as an s7 vector. */
                    s7_pointer x;
                    block_t *b;

                    new_cell(sc, x, T_FLOAT_VECTOR | T_SAFE_PROCEDURE);
                    b = mallocate_vector(sc, 0);
                    vector_block(x) = b;
                    /* block_data(b) = data; */
                    float_vector_floats(x) = data;
                    vector_getter(x) = float_vector_getter;
                    vector_setter(x) = float_vector_setter;
                    vector_length(x) = len;
                    if (!dim_info)
                    {
                        s7_int di[1];
                        di[0] = len;
                        vector_set_dimension_info(x, make_vdims(sc, free_data, 1, di));
                    }
                    else vector_set_dimension_info(x, make_vdims(sc, free_data, dims, dim_info));
                    add_multivector(sc, x);
                    return(x);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3d4b5
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200017, (%rbx)       # imm = 0x200017
cmpq $0x0, 0x838(%r14)
jne 0x3d518
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x3d4f6
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r14), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r14)
movl $0x0, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rbx)
movq %r12, 0x10(%rbx)
leaq 0x97(%rip), %rax        # 0x3d5e0
movq %rax, 0x20(%rbx)
leaq 0xe9(%rip), %rax        # 0x3d63d
movq %rax, 0x28(%rbx)
movq %r13, 0x8(%rbx)
testq %r15, %r15
je 0x3d572
movzbl %bpl, %esi
movq %r14, %rdi
movq 0x8(%rsp), %rdx
movq %r15, %rcx
jmp 0x3d586
leaq 0x10(%rsp), %rcx
movq %r13, (%rcx)
movzbl %bpl, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3d2c3
movq 0x18(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x790(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x3d5bb
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
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_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_set
s7_pointer s7_vector_set(s7_scheme *sc, s7_pointer vec, s7_int index, s7_pointer a)
                {
                    if (index >= vector_length(vec))
                        return(out_of_range(sc, sc->vector_set_symbol, small_int(2), wrap_integer1(sc, index), its_too_large_string));

                    if (is_typed_vector(vec))
                        return(typed_vector_setter(sc, vec, index, a));
                    vector_setter(vec)(sc, vec, index, T_Pos(a));
                    return(a);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
cmpq %rdx, 0x8(%rsi)
jle 0x3da5f
movq %rcx, %rbx
movq %rsi, %r12
testb $0x2, 0x6(%rsi)
jne 0x3dacc
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq *0x28(%r12)
jmp 0x3db29
movq 0x1668(%r14), %rax
movq 0x8(%rax), %rax
movq 0x110eef(%rip), %rcx    # 0x14e960
movq 0x1f00(%r14), %rdx
movq %r15, 0x8(%rdx)
movq 0x1ee8(%r14), %rdx
movq 0x1f00(%r14), %rsi
movq 0x114faf(%rip), %rdi    # 0x152a40
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%r14), %rbx
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b366
jmp 0x3db29
cmpq $0x0, 0x6a0(%r14)
js 0x3db20
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0x3dafd
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x3db17
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xbd41
cmpq 0x120(%r14), %rax
je 0x3db38
movq 0x10(%r12), %rax
movq %rbx, (%rax,%r15,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0x3db48
movq 0x8(%rsi), %rax
jmp 0x3db5c
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0xa05a7
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xa0491
leaq 0xdded5(%rip), %rsi     # 0x11ba48
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe25f
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_setter
static inline s7_pointer typed_vector_setter(s7_scheme *sc, s7_pointer vec, s7_int loc, s7_pointer val)
                {
                    if ((sc->safety < NO_SAFETY) || /* or == NO_SAFETY?? */
                            (typed_vector_typer_call(sc, vec, set_plist_1(sc, val)) != sc->F))
                    {
                        vector_element(vec, loc) = val;
                        return(val);
                    }
                    return(s7_wrong_type_arg_error(sc, "vector-set!", 3, val, make_type_name(sc, typed_vector_typer_name(sc, vec), INDEFINITE_ARTICLE)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
cmpq $0x0, 0x6a0(%rdi)
js 0x3dbf9
movq %rdi, %r14
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0x3dbd6
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x3dbf0
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xbd41
cmpq 0x120(%r14), %rax
je 0x3dc11
movq 0x10(%r12), %rax
movq %rbx, (%rax,%r15,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0x3dc21
movq 0x8(%rsi), %rax
jmp 0x3dc35
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0xa05a7
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xa0491
leaq 0xdddfc(%rip), %rsi     # 0x11ba48
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe25f
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_dimensions
s7_int s7_vector_dimensions(s7_pointer vec, s7_int *dims, s7_int dims_size)
                {
                    if (dims_size <= 0) return(0);
                    if (vector_dimension_info(vec))
                    {
                        s7_int i, lim;
                        lim = vector_ndims(vec);
                        if (lim > dims_size) lim = dims_size;
                        for (i = 0; i < lim; i++)
                            dims[i] = vector_dimension(vec, i);
                        return(lim);
                    }
                    dims[0] = vector_length(vec);
                    return(1);
                }

// Assembly:
testq %rdx, %rdx
jle 0x3dcbc
movq 0x18(%rdi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x3dcbf
movq %rdx, %rax
movq 0x10(%rcx), %rcx
cmpq %rdx, %rcx
cmovlq %rcx, %rax
testq %rcx, %rcx
jle 0x3dcbb
xorl %ecx, %ecx
movq 0x18(%rdi), %rdx
movq 0x20(%rdx), %rdx
movq (%rdx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3dca0
retq
xorl %eax, %eax
retq
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_offsets
s7_int s7_vector_offsets(s7_pointer vec, s7_int *offs, s7_int offs_size)
                {
                    if (offs_size <= 0) return(0);
                    if (vector_dimension_info(vec))
                    {
                        s7_int i, lim;
                        lim = vector_ndims(vec);
                        if (lim > offs_size) lim = offs_size;
                        for (i = 0; i < lim; i++)
                            offs[i] = vector_offset(vec, i);
                        return(lim);
                    }
                    offs[0] = 1;
                    return(1);
                }

// Assembly:
testq %rdx, %rdx
jle 0x3dd3e
movq 0x18(%rdi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x3dd41
movq %rdx, %rax
movq 0x10(%rcx), %rcx
cmpq %rdx, %rcx
cmovlq %rcx, %rax
testq %rcx, %rcx
jle 0x3dd3d
xorl %ecx, %ecx
movq 0x18(%rdi), %rdx
movq 0x20(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3dd21
retq
xorl %eax, %eax
retq
movq $0x1, (%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_set_n
s7_pointer s7_vector_set_n(s7_scheme *sc, s7_pointer vector, s7_pointer value, s7_int indices, ...)
                {
                    s7_int index;
                    va_list ap;
                    va_start(ap, indices);
                    index = flatten_multivector_indices(sc, vector, indices, ap);
                    if (is_typed_vector(vector))
                        return(typed_vector_setter(sc, vector, index, value));
                    return(vector_setter(vector)(sc, vector, index, value));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %rdx
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x3e031
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rax
movq %rdx, 0x10(%rax)
leaq 0x100(%rsp), %rdx
movq %rdx, 0x8(%rax)
movabsq $0x3000000020, %rdx     # imm = 0x3000000020
movq %rdx, (%rax)
movq %rcx, %rdx
movq %rax, %rcx
callq 0x3dde9
movq %rax, %r12
testb $0x2, 0x6(%r15)
jne 0x3e07b
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x28(%r15)
movq %rax, %rbx
jmp 0x3e0d6
cmpq $0x0, 0x6a0(%r14)
js 0x3e0ce
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0x3e0ab
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x3e0c5
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xbd41
cmpq 0x120(%r14), %rax
je 0x3e0e8
movq 0x10(%r15), %rax
movq %rbx, (%rax,%r12,8)
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0x3e0f7
movq 0x8(%rsi), %rax
jmp 0x3e10b
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0xa05a7
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xa0491
leaq 0xdd926(%rip), %rsi     # 0x11ba48
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
callq 0xe25f
jmp 0x3e076
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_vector_to_list
s7_pointer s7_vector_to_list(s7_scheme *sc, s7_pointer vect)
                {
                    s7_int i, len;
                    s7_pointer result;
                    len = vector_length(vect);
                    if (len == 0)
                        return(sc->nil);
                    check_heap_size(sc, len);
                    sc->v = sc->nil;
                    for (i = len - 1; i >= 0; i--)
                        sc->v = cons_unchecked(sc, vector_getter(vect)(sc, vect, i), sc->v);
                    result = sc->v;
                    sc->v = sc->nil;
                    return(result);
                }

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3e27b
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200015, (%rbx)       # imm = 0x200015
movq %r15, 0x8(%rbx)
shlq $0x3, %r15
testq %r15, %r15
jle 0x3e2b2
movq %r14, %rdi
movq %r15, %rsi
callq 0xa305
jmp 0x3e31a
cmpq $0x0, 0x838(%r14)
jne 0x3e2f8
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x3e2d6
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r14), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r14)
movl $0x0, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
movq $0x0, 0x20(%rax)
leaq 0x22ff1(%rip), %rax     # 0x61325
movq %rax, 0x20(%rbx)
leaq 0x22fef(%rip), %rax     # 0x6132e
movq %rax, 0x28(%rbx)
movq 0x740(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x3e36b
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_simple_byte_vector
static s7_pointer make_simple_byte_vector(s7_scheme *sc, s7_int len)
                {
                    s7_pointer x;
                    block_t *b;
                    new_cell(sc, x, T_BYTE_VECTOR | T_SAFE_PROCEDURE);
                    b = mallocate(sc, len);
                    vector_block(x) = b;
                    byte_vector_bytes(x) = (uint8_t *)block_data(b);
                    vector_length(x) = len;
                    vector_set_dimension_info(x, NULL);
                    vector_getter(x) = byte_vector_getter;
                    vector_setter(x) = byte_vector_setter;
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3f318
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200018, (%rbx)       # imm = 0x200018
movq %r14, %rdi
movq %r15, %rsi
callq 0xa305
movq %rax, 0x18(%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %r15, 0x8(%rbx)
movq $0x0, 0x20(%rax)
leaq 0x60e40(%rip), %rax     # 0xa019e
movq %rax, 0x20(%rbx)
leaq 0x60e49(%rip), %rax     # 0xa01b2
movq %rax, 0x28(%rbx)
movq 0x740(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x3f395
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: callocate
static block_t *callocate(s7_scheme *sc, size_t bytes)
    {
        block_t *p;
        p = mallocate(sc, bytes);
        if ((block_data(p)) && (block_index(p) != BLOCK_LIST))
        {
            if (block_index(p) >= 6)
                memclr64((void *)block_data(p), bytes);
            else memclr((void *)(block_data(p)), bytes);
        }
        return(p);
    }

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

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

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

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

// Assembly:
movsd 0x8(%rdx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3fa64
andpd 0xd3392(%rip), %xmm0    # 0x112dd0
movsd 0xcf612(%rip), %xmm1    # 0x10f058
ucomisd %xmm0, %xmm1
jbe 0x3fa5e
movsd 0xcf60c(%rip), %xmm1    # 0x10f060
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
retq
cvttsd2si %xmm0, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r14
testq %r14, %r14
je 0x3fbf4
movq %rdx, %r12
movq %rsi, %rbx
movq 0x10(%rdx), %rax
movq (%rax), %rdx
movzbl (%rdx), %esi
leaq 0x11afe9(%rip), %rcx    # 0x15ab80
cmpb $0x0, (%rsi,%rcx)
jne 0x3fbf4
testb $0x40, 0x3(%rdx)
jne 0x3fbf4
movq %rdi, %r15
cmpq $0x1, %r14
je 0x3fc01
movq 0x8(%rax), %rax
movzbl (%rax), %esi
cmpb $0x0, (%rsi,%rcx)
jne 0x3fc01
testb $0x40, 0x3(%rax)
jne 0x3fc01
movq 0x20(%rbx), %rax
movzbl (%rdx), %ecx
movq %r15, %rdi
movq %rbx, %rsi
callq *(%rax,%rcx,8)
movq %rax, %r13
addq %r14, %r13
movq 0x20(%rbx), %rax
movq 0x10(%r12), %rcx
movq 0x8(%rcx), %rdx
movzbl (%rdx), %ecx
movq %r15, %rdi
movq %rbx, %rsi
callq *(%rax,%rcx,8)
movq %rax, %r14
addq %r13, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rax
movzbl (%rdx), %ecx
movq (%rax,%rcx,8), %rax
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: hash_map_float_vector
static s7_int hash_map_float_vector(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (vector_length(key) == 0)
                        return(0);
                    if (vector_length(key) == 1)
                        return(hash_float_location(float_vector(key, 0)));
                    return(vector_length(key) + hash_float_location(float_vector(key, 0)) + hash_float_location(float_vector(key, 1)));
                }

// Assembly:
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x3fce9
cmpq $0x1, %rax
jne 0x3fcad
movq 0x10(%rdx), %rax
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3fd32
andpd 0xd3143(%rip), %xmm0    # 0x112dd0
movsd 0xcf3c3(%rip), %xmm1    # 0x10f058
ucomisd %xmm0, %xmm1
jbe 0x3fce4
movsd 0xcf3bd(%rip), %xmm1    # 0x10f060
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
retq
movq 0x10(%rdx), %rdx
movsd (%rdx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3fd35
andpd 0xd310d(%rip), %xmm0    # 0x112dd0
movsd 0xcf38d(%rip), %xmm1    # 0x10f058
ucomisd %xmm0, %xmm1
jbe 0x3fcea
movsd 0xcf387(%rip), %xmm1    # 0x10f060
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
jmp 0x3fcef
cvttsd2si %xmm0, %rax
retq
cvttsd2si %xmm0, %rcx
addq %rax, %rcx
movsd 0x8(%rdx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3fd39
andpd 0xd30cb(%rip), %xmm0    # 0x112dd0
movsd 0xcf34b(%rip), %xmm1    # 0x10f058
ucomisd %xmm0, %xmm1
jbe 0x3fd26
movsd 0xcf345(%rip), %xmm1    # 0x10f060
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
jmp 0x3fd2b
cvttsd2si %xmm0, %rax
addq %rax, %rcx
movq %rcx, %rax
retq
xorl %eax, %eax
retq
xorl %ecx, %ecx
jmp 0x3fcef
xorl %eax, %eax
jmp 0x3fd2b
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: hash_map_pair
static s7_int hash_map_pair(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    /* len+loc(car) is not horrible, but it means (for example) every list '(set! ...) is hashed to the same location,
                     *   so at least we need to take cadr into account if possible.  Better would combine the list_length
                     *   with stats like symbols/pairs/constants at top level, then use those to spread it out over all the locs.
                     */
                    s7_pointer p1;
                    s7_int loc = 0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdx), %rdx
movzbl (%rdx), %eax
leaq 0x11ad59(%rip), %r13    # 0x15ab80
cmpb $0x0, (%rax,%r13)
jne 0x3fe34
testb $0x40, 0x3(%rdx)
je 0x3fe4c
cmpb $0x1, %al
jne 0x3fe64
movq 0x8(%rdx), %rdx
movzbl (%rdx), %eax
cmpb $0x0, (%rax,%r13)
jne 0x3fe64
testb $0x40, 0x3(%rdx)
jne 0x3fe64
movq 0x20(%r15), %rax
movzbl (%rdx), %ecx
movq %r12, %rdi
movq %r15, %rsi
callq *(%rax,%rcx,8)
movq %rax, %r14
incq %r14
jmp 0x3fe67
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x3feb2
movq 0x8(%rax), %rdx
movzbl (%rdx), %eax
cmpb $0x0, (%rax,%r13)
jne 0x3fe84
testb $0x40, 0x3(%rdx)
je 0x3fe9c
cmpb $0x1, %al
jne 0x3feb2
movq 0x8(%rdx), %rdx
movzbl (%rdx), %eax
cmpb $0x0, (%rax,%r13)
jne 0x3feb2
testb $0x40, 0x3(%rdx)
jne 0x3feb2
movq 0x20(%r15), %rax
movzbl (%rdx), %ecx
movq %r12, %rdi
movq %r15, %rsi
callq *(%rax,%rcx,8)
addq %rax, %r14
incq %r14
cmpb $0x1, (%rbx)
jne 0x3fed0
xorl %ecx, %ecx
movq 0x10(%rbx), %rbx
leaq 0x1(%rcx), %rax
cmpb $0x1, (%rbx)
jne 0x3fed2
cmpl $0x7, %ecx
movq %rax, %rcx
jb 0x3feb9
jmp 0x3fed2
xorl %eax, %eax
shlq $0x3, %r14
orq %rax, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: hash_equal_syntax
static hash_entry_t *hash_equal_syntax(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    s7_int loc;
                    loc = hash_loc(sc, table, key) & hash_table_mask(table);
                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if ((is_syntax(hash_entry_key(x))) &&
                                (syntax_symbol(hash_entry_key(x)) == syntax_symbol(key))) /* the opcodes might differ, but the symbols should not */
                            return(x);
                    return(sc->unentry);
                }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rax
movzbl (%rdx), %ecx
callq *(%rax,%rcx,8)
andq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x400ae
cmpq %rbx, (%rax)
je 0x400b5
movq 0x18(%rax), %rax
jmp 0x4009e
movq 0x490(%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4021b
movq 0x8(%rdx), %rcx
movq 0x8(%rsi), %rax
andq %rcx, %rax
movq 0x10(%rsi), %rdx
movq (%rdx,%rax,8), %rax
testq %rax, %rax
sete %dl
je 0x4021b
movq (%rax), %rsi
cmpq %rcx, 0x8(%rsi)
je 0x40217
movq 0x18(%rax), %rax
jmp 0x40200
testb %dl, %dl
je 0x40222
movq 0x490(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: hash_float
static hash_entry_t *hash_float(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    /* give the equality check some room. also inf == inf and nan == nan */
                    if (type(key) == T_REAL)
                    {
                        s7_double keyval;
                        s7_int hash_mask, loc;

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

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

// Assembly:
cmpb $0xd, (%rdx)
jne 0x40264
movq 0x8(%rsi), %rax
movsd 0x8(%rdx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x40279
movapd 0xd2b91(%rip), %xmm1    # 0x112dd0
andpd %xmm0, %xmm1
movsd 0xcee0d(%rip), %xmm2    # 0x10f058
ucomisd %xmm1, %xmm2
jbe 0x4026c
movsd 0xcee07(%rip), %xmm2    # 0x10f060
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %rdx
jmp 0x40271
movq 0x490(%rdi), %rax
retq
cvttsd2si %xmm1, %rdx
andq %rax, %rdx
jmp 0xa0965
xorl %edx, %edx
jmp 0x40271
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: hash_symbol
static hash_entry_t *hash_symbol(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    for (x = hash_table_element(table, symbol_hmap(key) & hash_table_mask(table)); x; x = hash_entry_next(x))
                        if (key == hash_entry_key(x))
                            return(x);
                    return(sc->unentry);
                }

// Assembly:
movq 0x10(%rsi), %rax
movq %rdx, %rcx
sarq $0x8, %rcx
andq 0x8(%rsi), %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x402a0
cmpq %rdx, (%rax)
je 0x402a7
movq 0x18(%rax), %rax
jmp 0x40290
movq 0x490(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x402d3
movzbl 0x8(%rdx), %eax
andl 0x8(%rsi), %eax
movq 0x10(%rsi), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
sete %cl
je 0x402d3
cmpq %rdx, (%rax)
je 0x402cf
movq 0x18(%rax), %rax
jmp 0x402bc
testb %cl, %cl
je 0x402da
movq 0x490(%rdi), %rax
retq