LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: complex_equal
static bool complex_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_numbers_are_eqv(x, y));
#endif
                    return((is_t_complex(y)) &&
                            (real_part(x) == real_part(y)) &&
                            (imag_part(x) == imag_part(y)));
                }

// Assembly:
cmpb $0xe, (%rdx)
jne 0xc47d8
movsd 0x8(%rsi), %xmm0
ucomisd 0x8(%rdx), %xmm0
jne 0xc47d8
jp 0xc47d8
movsd 0x10(%rdx), %xmm0
cmpeqsd 0x10(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: symbol_equivalent
static bool symbol_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    if (x == y) return(true);
                    if (!is_normal_symbol(y)) return(false);            /* (equivalent? ''(1) '(1)) */
                    return((is_slot(global_slot(x))) &&                 /* the optimizer can replace the original symbol with its own */
                            (is_syntax(slot_value(global_slot(x)))) &&
                            (is_slot(global_slot(y))) &&
                            (is_syntax(slot_value(global_slot(y)))) &&
                            (syntax_symbol(slot_value(global_slot(x))) == syntax_symbol(slot_value(global_slot(y)))));
                }

// Assembly:
cmpq %rdx, %rsi
je 0xc481e
cmpb $0xa, (%rdx)
jne 0xc481b
testb $-0x80, 0x6(%rdx)
jne 0xc481b
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
jne 0xc481b
movq 0x10(%rax), %rax
cmpb $0x9, (%rax)
jne 0xc481b
movq 0x10(%rdx), %rcx
cmpb $0x20, (%rcx)
jne 0xc481b
movq 0x10(%rcx), %rcx
cmpb $0x9, (%rcx)
jne 0xc481b
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
sete %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_pointer_equivalent
static bool c_pointer_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    shared_info *nci = ci;
                    if (x == y) return(true);
                    if (!s7_is_c_pointer(y)) return(false);
                    if (c_pointer(x) != c_pointer(y)) return(false);
                    if (c_pointer_type(x) != c_pointer_type(y))
                    {
                        if (!nci) nci = new_shared_info(sc);
                        if (!s7_is_equivalent_1(sc, c_pointer_type(x), c_pointer_type(y), nci))
                            return(false);
                    }
                    if (c_pointer_info(x) != c_pointer_info(y))
                    {
                        if (!nci) nci = new_shared_info(sc);
                        if (!s7_is_equivalent_1(sc, c_pointer_info(x), c_pointer_info(y), nci))
                            return(false);
                    }
                    return(true);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb $0x1, %bl
cmpq %rdx, %rsi
je 0xc4849
movq %rdx, %r12
cmpb $0x21, (%rdx)
jne 0xc4847
movq %rsi, %r13
movq 0x8(%rsi), %rax
cmpq 0x8(%r12), %rax
je 0xc4855
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rcx, %r15
movq %rdi, %r14
movq 0x10(%r13), %rsi
movq 0x10(%r12), %rdx
cmpq %rdx, %rsi
je 0xc489a
testq %r15, %r15
jne 0xc4882
movq %r14, %rdi
callq 0x77cff
movq %rax, %r15
movq 0x10(%r13), %rsi
movq 0x10(%r12), %rdx
movzbl (%rsi), %eax
leaq 0x5d634(%rip), %r8      # 0x121ec0
movq %r14, %rdi
movq %r15, %rcx
callq *(%r8,%rax,8)
testb %al, %al
je 0xc4847
movq 0x18(%r13), %rsi
movq 0x18(%r12), %rdx
cmpq %rdx, %rsi
je 0xc4849
testq %r15, %r15
jne 0xc48c1
movq %r14, %rdi
callq 0x77cff
movq %rax, %r15
movq 0x18(%r13), %rsi
movq 0x18(%r12), %rdx
movzbl (%rsi), %eax
leaq 0x5d5f5(%rip), %r8      # 0x121ec0
movq %r14, %rdi
movq %r15, %rcx
callq *(%r8,%rax,8)
testb %al, %al
je 0xc4847
jmp 0xc4849
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: port_equivalent
static bool port_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    if (x == y) return(true);
                    if (type(x) != type(y)) return(false);
                    if ((port_is_closed(x)) && (port_is_closed(y))) return(true);
                    if ((port_is_closed(x)) || (port_is_closed(y))) return(false); /* if either is closed, port_port (below) might be null */
                    if (port_type(x) != port_type(y)) return(false);
                    switch (port_type(x))
                    {
                        case STRING_PORT:
                            return((port_position(x) == port_position(y)) &&
                                    (port_data_size(x) == port_data_size(y)) &&
                                    (local_strncmp((const char *)port_data(x), (const char *)port_data(y), (is_input_port(x)) ? port_data_size(x) : port_position(x))));
                        case FILE_PORT:
                            return((is_input_port(x)) &&
                                    (port_position(x) == port_position(y)) &&
                                    (local_strncmp((const char *)port_filename(x), (const char *)port_filename(y), port_filename_length(x))));
                        case FUNCTION_PORT:
                            if (is_input_port(x))
                                return(port_input_function(x) == port_input_function(y));
                            return(port_output_function(x) == port_output_function(y));
                    }
                    return(false);
                }

// Assembly:
cmpq %rdx, %rsi
je 0xc4a12
movb (%rsi), %cl
cmpb (%rdx), %cl
jne 0xc4a86
movq 0x8(%rsi), %r8
movb 0x2(%r8), %al
movq 0x8(%rdx), %rdi
movb 0x2(%rdi), %r9b
movl %eax, %r10d
orb %r9b, %r10b
testb $0x1, %r10b
je 0xc4a15
andb %r9b, %al
retq
movb $0x1, %al
retq
movl 0x4(%r8), %eax
cmpl 0x4(%rdi), %eax
jne 0xc4a86
testl %eax, %eax
je 0xc4a66
cmpl $0x2, %eax
je 0xc4a57
cmpl $0x1, %eax
jne 0xc4a86
movq 0x20(%rsi), %rax
cmpq 0x20(%rdx), %rax
jne 0xc4a86
movq 0x18(%rsi), %r8
cmpq 0x18(%rdx), %r8
jne 0xc4a86
movq 0x10(%rsi), %rdi
cmpb $0x23, %cl
cmoveq %r8, %rax
movq 0x10(%rdx), %rsi
movq %rax, %rdx
jmp 0x70ab0
cmpb $0x23, %cl
jne 0xc4a89
movq 0x50(%r8), %rax
cmpq 0x50(%rdi), %rax
jmp 0xc4a91
cmpb $0x23, %cl
jne 0xc4a86
movq 0x20(%rsi), %rax
cmpq 0x20(%rdx), %rax
jne 0xc4a86
movq 0x10(%rdi), %rsi
movq 0x10(%r8), %rdi
movq 0x30(%r8), %rdx
jmp 0x70ab0
xorl %eax, %eax
retq
movq 0x58(%r8), %rax
cmpq 0x58(%rdi), %rax
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: closure_equivalent
static bool closure_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    if (x == y)
                        return(true);
                    if (type(x) != type(y))
                        return(false);
                    if (has_active_methods(sc, y))
                        check_equivalent_method(sc, x, y);
                    /* not sure about this -- we can't simply check let_equal(closure_let(x), closure_let(y))
                     *   because locally defined constant functions on the second pass find the outer let.
                     */
                    return((s7_is_equivalent_1(sc, closure_args(x), closure_args(y), ci)) &&
                            (s7_is_equivalent_1(sc, closure_body(x), closure_body(y), ci)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
je 0xc4b8a
movq %rdx, %r15
movq %rsi, %r14
movb (%rsi), %al
cmpb (%rdx), %al
jne 0xc4bd0
movq %rcx, %r12
movq %rdi, %rbx
testb $0x40, 0x3(%r15)
je 0xc4b8e
cmpb $0x1, 0x24c(%rbx)
jne 0xc4b8e
testb $0x40, 0x3(%r14)
je 0xc4b8e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x1100(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0xc4b8e
movq %rax, %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xc4b33
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r14, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa34c
cmpq %rax, 0x120(%rbx)
setne %al
jmp 0xc4bd2
movb $0x1, %al
jmp 0xc4bd2
movq 0x8(%r14), %rsi
movq 0x8(%r15), %rdx
movzbl (%rsi), %eax
leaq 0x5d320(%rip), %r13     # 0x121ec0
movq %rbx, %rdi
movq %r12, %rcx
callq *(%r13,%rax,8)
testb %al, %al
je 0xc4bd0
movq 0x10(%r14), %rsi
movq 0x10(%r15), %rdx
movzbl (%rsi), %eax
movq (%r13,%rax,8), %rax
movq %rbx, %rdi
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: let_equivalent
static bool let_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    if (x == y) return(true);
                    check_equivalent_method(sc, x, y);
                    check_equivalent_method(sc, y, x);
                    return(let_equal_1(sc, x, y, ci, true));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
je 0xc4d8a
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testb $0x40, 0x3(%rsi)
je 0xc4caa
cmpb $0x1, 0x24c(%rbx)
jne 0xc4caa
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88f3
movq 0x1100(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0xc4caa
movq %rax, %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xc4c69
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r15, 0x8(%rdx)
jmp 0xc4d51
testb $0x40, 0x3(%r14)
je 0xc4d6c
cmpb $0x1, 0x24c(%rbx)
jne 0xc4d6c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0x1100(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0xc4d6c
movq %rax, %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xc4d15
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r14, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa34c
cmpq %rax, 0x120(%rbx)
setne %al
jmp 0xc4d8c
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc5e89
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: integer_equivalent
static bool integer_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_num_eq(sc, set_plist_2(sc, x, y)) != sc->F);
#endif
                    if (is_t_integer(y))
                        return(integer(x) == integer(y));
                    if (is_real(y))
                        return(floats_are_equivalent(sc, (double)integer(x), s7_real(y)));
                    if (is_t_complex(y))
                        return((fabs(imag_part(y)) <= sc->equivalent_float_epsilon) &&
                                (floats_are_equivalent(sc, (double)integer(x), real_part(y))));
                    return(false);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movzbl (%rdx), %eax
cmpq $0xb, %rax
jne 0xc554a
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
sete %al
jmp 0xc55a7
movq %rdi, %rbx
leaq 0x5445c(%rip), %rcx     # 0x1199b0
cmpb $0x1, (%rax,%rcx)
jne 0xc5585
cvtsi2sdq 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rdi
callq 0xc42a
movapd %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
jmp 0xc62fb
cmpl $0xe, %eax
jne 0xc55a5
movsd 0x10(%rdx), %xmm0
andpd 0x10929(%rip), %xmm0    # 0xd5ec0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0xc55ad
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
cvtsi2sdq 0x8(%rsi), %xmm0
movsd 0x8(%rdx), %xmm1
movq %rbx, %rdi
jmp 0xc557b
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fraction_equivalent
static bool fraction_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_num_eq(sc, set_plist_2(sc, x, y)) != sc->F);
#endif
                    if (is_real(y))
                        return(floats_are_equivalent(sc, (s7_double)fraction(x), s7_real(y)));
                    if (is_t_complex(y))
                        return((floats_are_equivalent(sc, (s7_double)fraction(x), real_part(y))) &&
                                (fabs(imag_part(y)) <= sc->equivalent_float_epsilon));
                    return(false);
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movzbl (%rdx), %eax
leaq 0x543dc(%rip), %rcx     # 0x1199b0
cmpb $0x1, (%rax,%rcx)
jne 0xc5624
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rcx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xc42a
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd (%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
jmp 0xc62fb
cmpb $0xe, %al
jne 0xc567f
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x30(%rsp)
fildll 0x30(%rsp)
movq %rcx, 0x28(%rsp)
fildll 0x28(%rsp)
fdivrp %st, %st(1)
fstpl 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x8(%r14), %xmm1
movq %rbx, %rdi
callq 0xc62fb
testb %al, %al
je 0xc567f
movsd 0x10(%r14), %xmm0
andpd 0x10852(%rip), %xmm0    # 0xd5ec0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
setae %al
jmp 0xc5681
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: real_equivalent
static bool real_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_num_eq(sc, set_plist_2(sc, x, y)) != sc->F);
#endif
                    if (is_real(y))
                        return(floats_are_equivalent(sc, real(x), s7_real(y)));
                    if (is_t_complex(y))
                        return((fabs(imag_part(y)) <= sc->equivalent_float_epsilon) &&
                                (floats_are_equivalent(sc, real(x), real_part(y))));
                    return(false);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzbl (%rdx), %eax
leaq 0x54315(%rip), %rcx     # 0x1199b0
cmpb $0x1, (%rax,%rcx)
jne 0xc56ca
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rdi
callq 0xc42a
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
jmp 0xc62fb
cmpb $0xe, %al
jne 0xc56e9
movsd 0x10(%rdx), %xmm0
andpd 0x107e5(%rip), %xmm0    # 0xd5ec0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0xc56f1
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movsd 0x8(%rsi), %xmm0
movsd 0x8(%rdx), %xmm1
movq %rbx, %rdi
jmp 0xc56c0
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: complex_equivalent
static bool complex_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_num_eq(sc, set_plist_2(sc, x, y)) != sc->F);
#endif
                    if (is_t_complex(y))
                        return((floats_are_equivalent(sc, real_part(x), real_part(y))) &&
                                (floats_are_equivalent(sc, imag_part(x), imag_part(y))));

                    if (is_real(y))
                        return((fabs(imag_part(x)) <= sc->equivalent_float_epsilon) &&
                                (floats_are_equivalent(sc, real_part(x), s7_real(y))));

                    return(false);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpq $0xe, %rax
jne 0xc5744
movsd 0x8(%r15), %xmm0
movsd 0x8(%r14), %xmm1
movq %rbx, %rdi
callq 0xc62fb
testb %al, %al
je 0xc576d
movsd 0x10(%r15), %xmm0
movsd 0x10(%r14), %xmm1
movq %rbx, %rdi
jmp 0xc5799
leaq 0x54265(%rip), %rcx     # 0x1199b0
cmpb $0x1, (%rax,%rcx)
jne 0xc576d
movsd 0x10(%r15), %xmm0
andpd 0x10761(%rip), %xmm0    # 0xd5ec0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0xc5779
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd 0x8(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xc42a
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xc62fb
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: add_shared_ref
static void add_shared_ref(shared_info *ci, s7_pointer x, int32_t ref_x)
    {
        /* called only in equality check, not printer */
        if (ci->top == ci->size)
            enlarge_shared_info(ci);
        set_collected(x);
        ci->objs[ci->top] = x;
        ci->refs[ci->top++] = ref_x;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0xc(%rdi), %eax
cmpl 0x8(%rdi), %eax
jne 0xc57de
movq %r14, %rdi
callq 0x78405
orb $0x2, 0x2(%r15)
movq (%r14), %rax
movslq 0xc(%r14), %rcx
movq %r15, (%rax,%rcx,8)
movq 0x20(%r14), %rax
leal 0x1(%rcx), %edx
movl %edx, 0xc(%r14)
movl %ebx, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: vector_rank_match
static bool vector_rank_match(s7_scheme *sc, s7_pointer x, s7_pointer y)
                {
                    s7_int x_dims;
                    s7_int j;

                    if (vector_has_dimensional_info(x))
                        x_dims = vector_ndims(x);
                    else return((!vector_has_dimensional_info(y)) || (vector_ndims(y) == 1));
                    if (x_dims == 1)
                        return((!vector_has_dimensional_info(y)) || (vector_ndims(y) == 1));

                    if ((!vector_has_dimensional_info(y)) ||
                            (x_dims != vector_ndims(y)))
                        return(false);

                    for (j = 0; j < x_dims; j++)
                        if (vector_dimension(x, j) != vector_dimension(y, j))
                            return(false);

                    return(true);
                }

// Assembly:
movq 0x18(%rdi), %rax
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0xc61d4
movq 0x10(%rdx), %rdi
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rcx
cmpq $0x1, %rdi
je 0xc61dc
testq %rcx, %rcx
je 0xc61ed
cmpq 0x10(%rcx), %rdi
jne 0xc61ed
xorl %esi, %esi
testq %rdi, %rdi
cmovleq %rsi, %rdi
cmpq %rsi, %rdi
sete %al
je 0xc61d3
movq (%rdx), %r8
movq (%r8,%rsi,8), %r8
movq (%rcx), %r9
leaq 0x1(%rsi), %r10
cmpq (%r9,%rsi,8), %r8
movq %r10, %rsi
je 0xc61b4
retq
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0xc61ea
cmpq $0x1, 0x10(%rcx)
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: biv_meq
static bool biv_meq(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    s7_int i, len;
                    uint8_t *xp;
                    s7_int *yp;
                    len = vector_length(x);
                    if (len != vector_length(y)) return(false);
                    xp = byte_vector_bytes(x);
                    yp = int_vector_ints(y);
                    for (i = 0; i < len; i++)
                        if ((s7_int)(xp[i]) != yp[i])
                            return(false);
                    return(true);
                }

// Assembly:
movq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
jne 0xc6226
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rsi
xorl %edi, %edi
testq %rcx, %rcx
cmovleq %rdi, %rcx
cmpq %rdi, %rcx
sete %al
je 0xc6225
movzbl (%rdx,%rdi), %r8d
leaq 0x1(%rdi), %r9
cmpq %r8, (%rsi,%rdi,8)
movq %r9, %rdi
je 0xc620b
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: iv_meq
static bool iv_meq(s7_int *ex, s7_int *ey, s7_int len)
                {
                    s7_int i, left;
                    left = len - 8;
                    i = 0;
                    while (i <= left)
                        LOOP_8(if (ex[i] != ey[i]) return(false); i++);
                    for (; i < len; i++)
                        if (ex[i] != ey[i])
                            return(false);
                    return(true);
                }

// Assembly:
leaq -0x8(%rdx), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jg 0xc62a9
movq (%rdi,%rcx,8), %r8
cmpq (%rsi,%rcx,8), %r8
jne 0xc62b2
movq 0x8(%rdi,%rcx,8), %r8
cmpq 0x8(%rsi,%rcx,8), %r8
jne 0xc62b2
movq 0x10(%rdi,%rcx,8), %r8
cmpq 0x10(%rsi,%rcx,8), %r8
jne 0xc62b2
movq 0x18(%rdi,%rcx,8), %r8
cmpq 0x18(%rsi,%rcx,8), %r8
jne 0xc62b2
movq 0x20(%rdi,%rcx,8), %r8
cmpq 0x20(%rsi,%rcx,8), %r8
jne 0xc62b2
movq 0x28(%rdi,%rcx,8), %r8
cmpq 0x28(%rsi,%rcx,8), %r8
jne 0xc62b2
movq 0x30(%rdi,%rcx,8), %r8
cmpq 0x30(%rsi,%rcx,8), %r8
jne 0xc62b2
movq 0x38(%rdi,%rcx,8), %r8
cmpq 0x38(%rsi,%rcx,8), %r8
jne 0xc62b2
addq $0x8, %rcx
jmp 0xc622f
movq (%rdi,%rcx,8), %r8
leaq 0x1(%rcx), %r9
cmpq (%rsi,%rcx,8), %r8
movq %r9, %rcx
jne 0xc62b1
cmpq %rdx, %rcx
setge %al
jl 0xc6298
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_equal
static bool byte_vector_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    s7_int i, len;
                    uint8_t *xp, *yp;

                    if (x == y) return(true);
                    if (type(x) != type(y)) return(false);
                    len = vector_length(x);
                    if (len != vector_length(y)) return(false);

                    xp = byte_vector_bytes(x);
                    yp = byte_vector_bytes(y);
                    for (i = 0; i < len; i++)
                        if (xp[i] != yp[i])
                            return(false);
                    return(true);
                }

// Assembly:
cmpq %rsi, %rdi
je 0xc62f8
movb (%rdi), %al
cmpb (%rsi), %al
jne 0xc62f5
movq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
jne 0xc62f5
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rsi
xorl %edi, %edi
testq %rcx, %rcx
cmovleq %rdi, %rcx
cmpq %rdi, %rcx
sete %al
je 0xc62f4
movb (%rdx,%rdi), %r8b
leaq 0x1(%rdi), %r9
cmpb (%rsi,%rdi), %r8b
movq %r9, %rdi
je 0xc62db
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: floats_are_equivalent
static bool floats_are_equivalent(s7_scheme *sc, s7_double x, s7_double y)
                {
                    s7_double diff, eps;
                    if (x == y) return(true);
                    eps = sc->equivalent_float_epsilon;
                    diff = fabs(x - y);
                    if (diff <= eps) return(true);

                    if ((is_NaN(x)) || (is_NaN(y)))
                        return((is_NaN(x)) && (is_NaN(y)));

                    if (x < 0.0) x = -x;
                    return((x > 1.0) &&
                            (diff < (x * eps)));
                }

// Assembly:
movb $0x1, %al
ucomisd %xmm1, %xmm0
jne 0xc6305
jnp 0xc6357
movsd 0x260(%rdi), %xmm3
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
andpd 0xfba3(%rip), %xmm2     # 0xd5ec0
ucomisd %xmm2, %xmm3
jae 0xc6357
ucomisd %xmm1, %xmm0
jp 0xc635a
movapd 0xfb7f(%rip), %xmm1     # 0xd5eb0
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
mulsd %xmm1, %xmm3
movsd 0xbceb(%rip), %xmm0     # 0xd2030
cmpltpd %xmm1, %xmm0
cmpltpd %xmm3, %xmm2
andpd %xmm0, %xmm2
movd %xmm2, %eax
andb $0x1, %al
retq
xorpd %xmm2, %xmm2
cmpunordpd %xmm2, %xmm1
cmpunordpd %xmm2, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
jmp 0xc6357
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_string
static s7_pointer make_permanent_string(const char *str)
    {
        s7_pointer x;
        s7_int len;

        x = (s7_pointer)calloc(1, sizeof(s7_cell));
        set_type(x, T_STRING | T_IMMUTABLE | T_UNHEAP);
        len = safe_strlen(str);
        string_length(x) = len;
        string_block(x) = NULL;
        string_value(x) = (char *)str;
        string_hash(x) = 0;
        return(x);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x8360
movq %rax, %r14
movabsq $0x4000000001000013, %rax # imm = 0x4000000001000013
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x8d06
movq %rax, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_recur_if_a_a_opa_laq
static s7_pointer fx_recur_if_a_a_opa_laq(s7_scheme *sc, s7_pointer arg)
                {
#if S7_DEBUGGING
                    tc_rec_calls[OP_RECUR_IF_A_A_opA_LAq]++;
#endif
                    sc->rec_stack = recur_make_stack(sc);
                    opinit_if_a_a_opa_laq(sc, true, arg);
                    sc->value = oprec_if_a_a_opa_laq(sc);
                    sc->rec_loc = 0;
                    return(sc->value);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5fef
movq %rax, 0x2e8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xa6028
movq %r14, %rdi
callq 0xa60e1
movq %rax, 0x20(%r14)
andq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_recur_if_a_opa_laq_a
static s7_pointer fx_recur_if_a_opa_laq_a(s7_scheme *sc, s7_pointer arg)
                {
#if S7_DEBUGGING
                    tc_rec_calls[OP_RECUR_IF_A_opA_LAq_A]++;
#endif
                    sc->rec_stack = recur_make_stack(sc);
                    opinit_if_a_a_opa_laq(sc, false, arg);
                    sc->value = oprec_if_a_opa_laq_a(sc);
                    sc->rec_loc = 0;
                    return(sc->value);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5fef
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xa6028
movq %r14, %rdi
callq 0xa6219
movq %rax, 0x20(%r14)
andq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_recur_if_a_a_and_a_laa_laa
static s7_pointer fx_recur_if_a_a_and_a_laa_laa(s7_scheme *sc, s7_pointer arg)
                {
#if S7_DEBUGGING
                    tc_rec_calls[OP_RECUR_IF_A_A_AND_A_LAA_LAA]++;
#endif
                    /* sc->envir is set already and will be restored by the caller */
                    sc->rec_stack = recur_make_stack(sc);
                    opinit_if_a_a_and_a_laa_laa(sc, arg);
                    sc->value = oprec_if_a_a_and_a_laa_laa(sc);
                    sc->rec_loc = 0;
                    return(sc->value);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5fef
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa7289
movq %r14, %rdi
callq 0xa73ab
movq %rax, 0x20(%r14)
andq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_recur_cond_a_a_a_a_opla_laq
static s7_pointer fx_recur_cond_a_a_a_a_opla_laq(s7_scheme *sc, s7_pointer arg)
                {
#if S7_DEBUGGING
                    tc_rec_calls[OP_RECUR_COND_A_A_A_A_opLA_LAq]++;
#endif
                    sc->rec_stack = recur_make_stack(sc);
                    opinit_cond_a_a_a_a_opla_laq(sc, arg);
                    sc->value = oprec_cond_a_a_a_a_opla_laq(sc);
                    sc->rec_loc = 0;
                    return(sc->value);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5fef
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa79eb
movq %r14, %rdi
callq 0xa7af8
movq %rax, 0x20(%r14)
andq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: catch_all_function
static bool catch_all_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    s7_pointer catcher;
                    catcher = stack_let(sc->stack, i);
                    sc->value = stack_args(sc->stack, i);
                    sc->op_stack_now = (s7_pointer *)(sc->op_stack + catch_all_op_loc(catcher));
                    sc->stack_end = (s7_pointer *)(sc->stack_start + catch_all_goto_loc(catcher));
                    pop_stack(sc);
                    if (is_pair(sc->value))
                    {
                        if (car(sc->value) == sc->quote_symbol)
                            sc->value = cadr(sc->value);
                        else sc->value = type;
                    }
                    else
                    {
                        if (is_symbol(sc->value))
                            sc->value = type;
                    }
                    return(true);
                }

// Assembly:
movq 0x38(%rdi), %rax
movq 0x48(%rdi), %rcx
movq 0x10(%rax), %rax
movq -0x10(%rax,%rsi,8), %r8
movq -0x8(%rax,%rsi,8), %rax
movq %rax, 0x20(%rdi)
movq 0x20(%r8), %rsi
shlq $0x3, %rsi
addq 0x60(%rdi), %rsi
movq %rsi, 0x68(%rdi)
movq 0x28(%r8), %rsi
leaq (%rcx,%rsi,8), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rdi)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0xc6685
cmpl $0x1, %ecx
jne 0xc6689
movq 0x8(%rax), %rcx
cmpq 0x17b0(%rdi), %rcx
jne 0xc6685
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: catch_2_function
static bool catch_2_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    /* this is the macro-error-handler case from g_catch
                     *    (let () (define-macro (m . args) (apply (car args) (cadr args))) (catch #t (lambda () (error abs -1)) m))
                     */
                    s7_pointer x;
                    x = stack_code(sc->stack, i);
                    if ((catch_tag(x) == sc->T) ||
                            (catch_tag(x) == type) ||
                            (type == sc->T))
                    {
                        int64_t loc;
                        loc = catch_goto_loc(x);
                        sc->op_stack_now = (s7_pointer *)(sc->op_stack + catch_op_loc(x));
                        sc->stack_end = (s7_pointer *)(sc->stack_start + loc);
                        sc->code = catch_handler(x);

                        if (needs_copied_args(sc->code))
                            sc->args = list_2(sc, type, info);
                        else           /* very unlikely: need c_macro as error catcher: (catch #t (lambda () (error 'oops)) require) */
                        {
                            set_car(sc->t2_1, type);
                            set_car(sc->t2_2, info);
                            sc->args = sc->t2_1;
                        }
                        sc->cur_op = OP_APPLY;
                        return(true);
                    }
                    return(false);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq 0x38(%rdi), %rax
movq 0x118(%rdi), %rcx
movq 0x10(%rax), %rax
movq -0x18(%rax,%rsi,8), %rax
movq 0x18(%rax), %rdx
cmpq %rcx, %rdx
sete %sil
cmpq %r14, %rdx
sete %dl
orb %sil, %dl
cmpq %r14, %rcx
sete %bpl
orb %dl, %bpl
cmpb $0x1, %bpl
jne 0xc6797
movq %rdi, %rbx
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
shlq $0x3, %rdx
addq 0x60(%rdi), %rdx
movq %rdx, 0x68(%rdi)
shlq $0x3, %rcx
addq 0x48(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq 0x20(%rax), %rax
movq %rax, (%rdi)
testb $0x10, 0x3(%rax)
jne 0xc6725
movq 0x570(%rbx), %rax
movq %r14, 0x8(%rax)
movq 0x578(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x570(%rbx), %rax
jmp 0xc678b
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xc674b
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rax), %rax
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x10(%rbx)
movq $0x198, 0x18(%rbx)      # imm = 0x198
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: catch_dw_function
static bool catch_dw_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    s7_pointer x;
                    x = stack_code(sc->stack, i);
                    if (dynamic_wind_state(x) == DWIND_BODY)
                    {
                        dynamic_wind_state(x) = DWIND_FINISH;    /* make sure an uncaught error in the exit thunk doesn't cause us to loop */
                        if (dynamic_wind_out(x) != sc->F)
                        {
                            push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                            sc->code = dynamic_wind_out(x);
                            sc->args = sc->nil;
                            eval(sc, OP_APPLY);                  /* I guess this means no call/cc out of the exit thunk in an error-catching context */
                        }
                    }
                    return(false);
                }

// Assembly:
movq 0x38(%rdi), %rax
movq 0x10(%rax), %rax
movq -0x18(%rax,%rsi,8), %rax
cmpl $0x1, 0x20(%rax)
jne 0xc6b6b
movl $0x2, 0x20(%rax)
movq 0x10(%rax), %rcx
cmpq 0x120(%rdi), %rcx
je 0xc6b6b
pushq %rax
movq (%rdi), %rcx
movq 0x50(%rdi), %rdx
movq %rcx, (%rdx)
movq 0x8(%rdi), %rcx
movq 0x50(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x10(%rdi), %rcx
movq 0x50(%rdi), %rdx
movq %rcx, 0x10(%rdx)
movq 0x50(%rdi), %rcx
movq $0x1df, 0x18(%rcx)      # imm = 0x1DF
addq $0x20, 0x50(%rdi)
movq 0x10(%rax), %rax
movq %rax, (%rdi)
movq 0x110(%rdi), %rax
movq %rax, 0x10(%rdi)
movl $0x198, %esi            # imm = 0x198
callq 0xe1a8
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: catch_out_function
static bool catch_out_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    s7_pointer x;
                    x = stack_code(sc->stack, i);                /* "code" = port that we opened */
                    s7_close_output_port(sc, x);
                    x = stack_args(sc->stack, i);                /* "args" = port that we shadowed, if not #<unused> */
                    if (x != sc->unused)
                        sc->output_port = x;
                    return(false);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x10(%rax), %rax
movq -0x18(%rax,%rsi,8), %rsi
callq 0xd6b6
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rax
movq -0x8(%rax,%r14,8), %rax
cmpq 0x140(%rbx), %rax
je 0xc6ba7
movq %rax, 0x188(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: catch_barrier_function
static bool catch_barrier_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    if (is_input_port(stack_args(sc->stack, i)))      /* (eval-string "'(1 .)") */
                    {
                        if (sc->input_port == stack_args(sc->stack, i))
                            pop_input_port(sc);
                        s7_close_input_port(sc, stack_args(sc->stack, i));
                    }
                    return(false);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x38(%rdi), %rax
movq 0x10(%rax), %rax
movq -0x8(%rax,%rsi,8), %rsi
cmpb $0x23, (%rsi)
jne 0xc6c65
movq %rdi, %rbx
cmpq %rsi, 0x170(%rdi)
jne 0xc6c57
movq %rbx, %rdi
callq 0x29472
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rax
movq -0x8(%rax,%r14,8), %rsi
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *0x48(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_gc_list
static gc_list *make_gc_list(void)
    {
        gc_list *gp;
#define INIT_GC_CACHE_SIZE 4
        gp = (gc_list *)malloc(sizeof(gc_list));
        gp->size = INIT_GC_CACHE_SIZE;
        gp->loc = 0;
        gp->list = (s7_pointer *)malloc(gp->size * sizeof(s7_pointer));
        return(gp);
    }

// Assembly:
pushq %rbx
pushq $0x18
popq %rdi
callq 0x8480
movq %rax, %rbx
movq $0x4, 0x8(%rax)
andq $0x0, 0x10(%rax)
pushq $0x20
popq %rdi
callq 0x8480
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: stdout_write_string
static void stdout_write_string(s7_scheme *sc, const char *str, s7_int len, s7_pointer port)
    {
        if (str[len] == '\0')
            fputs(str, stdout);
        else
        {
            s7_int i;
            for (i = 0; i < len; i++)
                fputc(str[i], stdout);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi,%rdx)
je 0xc6dd2
movq %rdx, %r14
xorl %r15d, %r15d
testq %rdx, %rdx
cmovleq %r15, %r14
movq 0x4e222(%rip), %r12     # 0x114fd0
cmpq %r15, %r14
je 0xc6dc6
movsbl (%rbx,%r15), %edi
movq (%r12), %rsi
callq 0x8300
incq %r15
jmp 0xc6dae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4e1f7(%rip), %rax     # 0x114fd0
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8250
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: stderr_write_string
static void stderr_write_string(s7_scheme *sc, const char *str, s7_int len, s7_pointer port)
    {
        if (str[len] == '\0')
            fputs(str, stderr);
        else
        {
            s7_int i;
            for (i = 0; i < len; i++)
                fputc(str[i], stderr);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi,%rdx)
je 0xc6e65
movq %rdx, %r14
xorl %r15d, %r15d
testq %rdx, %rdx
cmovleq %r15, %r14
movq 0x4e1b7(%rip), %r12     # 0x114ff8
cmpq %r15, %r14
je 0xc6e59
movsbl (%rbx,%r15), %edi
movq (%r12), %rsi
callq 0x8300
incq %r15
jmp 0xc6e41
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4e18c(%rip), %rax     # 0x114ff8
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8250
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: stdin_read_line
static s7_pointer stdin_read_line(s7_scheme *sc, s7_pointer port, bool with_eol, bool copied)
    {
        if (!sc->read_line_buf)
        {
            sc->read_line_buf_size = 1024;
            sc->read_line_buf = (char *)malloc(sc->read_line_buf_size);
        }

        if (fgets(sc->read_line_buf, sc->read_line_buf_size, stdin))
            return(s7_make_string(sc, sc->read_line_buf)); /* fgets adds the trailing '\0' */
        return(make_string_with_length(sc, NULL, 0));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x4b8(%rdi), %rdi
testq %rdi, %rdi
je 0xc6eb6
movl 0x4c0(%rbx), %esi
jmp 0xc6eda
movq $0x400, 0x4c0(%rbx) # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x8480
movq %rax, %rdi
movq %rax, 0x4b8(%rbx)
movl $0x400, %esi            # imm = 0x400
movq 0x4e0f7(%rip), %rax     # 0x114fd8
movq (%rax), %rdx
callq 0x8330
testq %rax, %rax
je 0xc6efe
movq 0x4b8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xd1fd
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0xd11d
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_string_to_symbol_1
static inline s7_pointer g_string_to_symbol_1(s7_scheme *sc, s7_pointer str, s7_pointer caller)
    {
        if (is_string(str))
        {
            if (string_length(str) > 0)
                return(make_symbol_with_length(sc, string_value(str), string_length(str)));
            return(simple_wrong_type_argument_with_type(sc, caller, str, wrap_string(sc, "a non-null string", 17)));
            /* currently if the string has an embedded null, it marks the end of the new symbol name. */
        }
        return(method_or_bust_one_arg(sc, str, caller, list_1(sc, str), T_STRING));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x13, (%rsi)
jne 0xc6f42
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
jle 0xc6fa3
movq 0x10(%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8c3b
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0xc6f68
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %rbx, 0x8(%rcx)
movq %r12, 0x10(%rcx)
pushq $0x13
popq %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x77745
movq 0x8(%r15), %rsi
movq 0x140(%r14), %rcx
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rdx
movq (%rax,%rdx,8), %r8
leal 0x1(%rdx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r14)
leaq 0x204cc(%rip), %rax     # 0xe74a0
movq %rax, 0x10(%r8)
movq $0x11, 0x8(%r8)
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: find_dynamic_value
static s7_pointer find_dynamic_value(s7_scheme *sc, s7_pointer x, s7_pointer sym, int64_t *id)
    {
        for (; symbol_id(sym) < let_id(x); x = outlet(x));

        if (let_id(x) == symbol_id(sym))
        {
            (*id) = let_id(x);
            return(slot_value(local_slot(sym)));
        }
        for (; (is_let(x)) && (let_id(x) > (*id)); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == sym)
                {
                    (*id) = let_id(x);
                    return(slot_value(y));
                }
        }
        return(sc->unused);
    }

// Assembly:
movq 0x20(%rdx), %rax
movq 0x18(%rsi), %r8
cmpq %r8, %rax
jge 0xc731b
movq 0x10(%rsi), %rsi
jmp 0xc730c
jne 0xc732a
movq %rax, (%rcx)
movq 0x18(%rdx), %rdi
addq $0x10, %rdi
jmp 0xc7360
cmpb $0x1c, (%rsi)
jne 0xc7364
movq 0x18(%rsi), %rax
cmpq (%rcx), %rax
jle 0xc7364
leaq 0x8(%rsi), %r8
movq (%r8), %r8
testq %r8, %r8
je 0xc7350
cmpq %rdx, 0x8(%r8)
je 0xc7356
addq $0x18, %r8
jmp 0xc733c
movq 0x10(%rsi), %rsi
jmp 0xc732a
movq %rax, (%rcx)
addq $0x10, %r8
movq %r8, %rdi
movq (%rdi), %rax
retq
addq $0x140, %rdi            # imm = 0x140
jmp 0xc7360
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: open_and_protect_input_string
static inline s7_pointer open_and_protect_input_string(s7_scheme *sc, s7_pointer str)
    {
        s7_pointer p;
        p = open_input_string(sc, string_value(str), string_length(str));
        port_gc_loc(p) = s7_gc_protect_1(sc, str);
        port_needs_unprotect(p) = true;
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rsi
callq 0xdb15
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x89a9
movq 0x8(%r15), %rcx
movq %rax, 0x28(%rcx)
movq 0x8(%r15), %rax
movb $0x1, 0x1(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: input_port_if_not_loading
static s7_pointer input_port_if_not_loading(s7_scheme *sc)
    {
        s7_pointer port;
        port = sc->input_port;
        if (is_loader_port(port)) /* this flag is turned off by the reader macros, so we aren't in that context */
        {
            int32_t c;
            c = port_read_white_space(port)(sc, port);
            if (c > 0)            /* we can get either EOF or NULL at the end */
            {
                backchar(c, port);
                return(NULL);
            }
            return(sc->standard_input);
        }
        return(port);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x170(%rdi), %rbx
testb $0x4, 0x2(%rbx)
je 0xc7442
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %rbx, %rsi
callq *0x20(%rax)
testl %eax, %eax
jle 0xc743b
movsbl %al, %edi
movq %rbx, %rsi
callq 0xdf3a
xorl %ebx, %ebx
jmp 0xc7442
movq 0x1c8(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: call_with_input
static s7_pointer call_with_input(s7_scheme *sc, s7_pointer port, s7_pointer args)
    {
        s7_pointer p;
        p = cadr(args);
        port_original_input_string(port) = car(args);
        push_stack(sc, OP_UNWIND_INPUT, sc->input_port, port);
        push_stack(sc, OP_APPLY, list_1(sc, port), p);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rax
movq 0x10(%rdx), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rsi), %rdx
movq %rax, 0x40(%rdx)
movq 0x50(%rdi), %rax
movq %rsi, (%rax)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x50(%rdi), %rax
movq 0x170(%rdi), %rdx
movq %rdx, 0x10(%rax)
movq 0x50(%rdi), %rax
movq $0x1ee, 0x18(%rax)      # imm = 0x1EE
movq 0x50(%rdi), %rax
leaq 0x20(%rax), %rdx
movq %rdx, 0x50(%rdi)
movq %rcx, 0x20(%rax)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x90(%rdi), %rax
movq 0x110(%rdi), %r15
cmpq 0x98(%rdi), %rax
ja 0xc74dc
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x198, 0x18(%rax)      # imm = 0x198
addq $0x20, 0x50(%rbx)
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_complex
static s7_pointer c_complex(s7_scheme *sc, s7_double rl, s7_double im)
    {
        /* same as s7_make_complex, but assumes im is not 0.0 */
        s7_pointer x;
        new_cell(sc, x, T_COMPLEX);
        set_real_part(x, rl);
        set_imag_part(x, im);
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xc75f9
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x9c27
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xe, (%rax)
movsd %xmm0, 0x8(%rax)
movsd %xmm1, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq