LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: c_pointer_equal
static bool c_pointer_equal(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_equal_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_equal_1(sc, c_pointer_info(x), c_pointer_info(y), nci))
                            return(false);
                    }
                    return(true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x1, %bl
cmpq %rdx, %rsi
je 0xfee89
movq %rdx, %r12
cmpb $0x21, (%rdx)
jne 0xfee87
movq %rsi, %r13
movq 0x8(%rsi), %rax
cmpq 0x8(%r12), %rax
je 0xfee9a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r15
movq %rdi, %r14
movq 0x10(%r13), %rax
cmpq 0x10(%r12), %rax
je 0xfefc4
testq %r15, %r15
jne 0xfef9f
movq 0x6c0(%r14), %r15
movslq 0xc(%r15), %rbp
testq %rbp, %rbp
jle 0xfef92
movl %ebp, %eax
movq 0x20(%r15), %rdi
shlq $0x2, %rbp
cmpl $0x1, %eax
je 0xfef0b
movabsq $0x1fffffff8, %rdx      # imm = 0x1FFFFFFF8
andq %rbp, %rdx
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x9270
movq 0x8(%rsp), %rdi
addq 0x10(%rsp), %rdi
andl $0x4, %ebp
testq %rbp, %rbp
je 0xfef1a
xorl %esi, %esi
movq %rbp, %rdx
callq 0x9270
movq 0x48(%r15), %rdi
movslq 0xc(%r15), %rbp
cmpq $0x8, %rbp
jb 0xfef52
movq %rbp, %rdx
andq $-0x8, %rdx
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x9270
movq 0x8(%rsp), %rdi
addq 0x10(%rsp), %rdi
andl $0x7, %ebp
testq %rbp, %rbp
je 0xfef61
xorl %esi, %esi
movq %rbp, %rdx
callq 0x9270
cmpl $0x0, 0xc(%r15)
jle 0xfef8a
xorl %eax, %eax
movabsq $-0x600000000a0001, %rcx # imm = 0xFF9FFFFFFFF5FFFF
movq (%r15), %rdx
movq (%rdx,%rax,8), %rdx
andq %rcx, (%rdx)
incq %rax
movslq 0xc(%r15), %rdx
cmpq %rdx, %rax
jl 0xfef74
movl $0x0, 0xc(%r15)
movl $0x0, 0x10(%r15)
movb $0x0, 0x18(%r15)
movq 0x10(%r13), %rsi
movq 0x10(%r12), %rdx
movzbl (%rsi), %eax
leaq 0x5bd6e(%rip), %r8      # 0x15ad20
movq %r14, %rdi
movq %r15, %rcx
callq *(%r8,%rax,8)
testb %al, %al
je 0xfee87
movq 0x18(%r13), %rax
cmpq 0x18(%r12), %rax
je 0xfee89
testq %r15, %r15
jne 0xfefe3
movq %r14, %rdi
callq 0x9c66c
movq %rax, %r15
movq 0x18(%r13), %rsi
movq 0x18(%r12), %rdx
movzbl (%rsi), %eax
leaq 0x5bd2a(%rip), %r8      # 0x15ad20
movq %r14, %rdi
movq %r15, %rcx
callq *(%r8,%rax,8)
testb %al, %al
je 0xfee87
jmp 0xfee89
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: rng_equal
static bool rng_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    return(x == y);
#else
                    return((x == y) ||
                            ((is_random_state(y)) &&
                             (random_seed(x) == random_seed(y)) &&
                             (random_carry(x) == random_carry(y))));
#endif
                }

// Assembly:
cmpq %rdx, %rsi
je 0xff2d7
cmpb $0x24, (%rdx)
jne 0xff2d4
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
jne 0xff2d4
movq 0x10(%rsi), %rax
cmpq 0x10(%rdx), %rax
sete %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: closure_equal
static bool closure_equal(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, x)) &&
                            (has_active_methods(sc, y)))
                    {
                        s7_pointer equal_func;
                        equal_func = find_method(sc, closure_let(x), sc->is_equal_symbol);
                        if (equal_func != sc->undefined)
                            return(s7_boolean(sc, s7_apply_function(sc, equal_func, list_2(sc, x, y))));
                    }
                    return(false);
                }

// Assembly:
cmpq %rdx, %rsi
je 0xff3d6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movb (%rsi), %al
cmpb (%rdx), %al
jne 0xff3df
testb $0x40, 0x3(%r14)
je 0xff3df
movq %rdi, %rbx
cmpb $0x1, 0x24c(%rdi)
jne 0xff3df
testb $0x40, 0x3(%r15)
je 0xff3df
movq 0x18(%r14), %rsi
movq 0x1070(%rbx), %rdx
movq %rbx, %rdi
callq 0x99ef
movq %rax, %r12
movq 0x128(%rbx), %r13
cmpq %r13, %rax
je 0xff3da
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xff378
movq %rbx, %rdi
callq 0xb389
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 %rbp, 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 %r12, %rsi
callq 0xbd41
cmpq %rax, 0x120(%rbx)
setne %al
jmp 0xff3da
movb $0x1, %al
jmp 0xff3ef
cmpq %r13, %r12
jne 0xff3e1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fraction_equal
static bool fraction_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((s7_is_ratio(y)) &&
                            (numerator(x) == numerator(y)) &&
                            (denominator(x) == denominator(y)));
                }

// Assembly:
cmpb $0xc, (%rdx)
jne 0xffb7c
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
jne 0xffb7c
movq 0x10(%rsi), %rax
cmpq 0x10(%rdx), %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: real_equal
static bool real_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_real(y)) &&
                            (real(x) == real(y)));
                }

// Assembly:
cmpb $0xd, (%rdx)
jne 0xffb98
movsd 0x8(%rdx), %xmm0
cmpeqsd 0x8(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xffbc2
movsd 0x8(%rsi), %xmm0
ucomisd 0x8(%rdx), %xmm0
jne 0xffbc2
jp 0xffbc2
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_O1/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 0xffc08
cmpb $0xa, (%rdx)
jne 0xffc05
testb $-0x80, 0x6(%rdx)
jne 0xffc05
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
jne 0xffc05
movq 0x10(%rax), %rax
cmpb $0x9, (%rax)
jne 0xffc05
movq 0x10(%rdx), %rcx
cmpb $0x20, (%rcx)
jne 0xffc05
movq 0x10(%rcx), %rcx
cmpb $0x9, (%rcx)
jne 0xffc05
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x1, %bl
cmpq %rdx, %rsi
je 0xffc38
movq %rdx, %r12
cmpb $0x21, (%rdx)
jne 0xffc36
movq %rsi, %r13
movq 0x8(%rsi), %rax
cmpq 0x8(%r12), %rax
je 0xffc49
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r15
movq %rdi, %r14
movq 0x10(%r13), %rax
cmpq 0x10(%r12), %rax
je 0xffd73
testq %r15, %r15
jne 0xffd4e
movq 0x6c0(%r14), %r15
movslq 0xc(%r15), %rbp
testq %rbp, %rbp
jle 0xffd41
movl %ebp, %eax
movq 0x20(%r15), %rdi
shlq $0x2, %rbp
cmpl $0x1, %eax
je 0xffcba
movabsq $0x1fffffff8, %rdx      # imm = 0x1FFFFFFF8
andq %rbp, %rdx
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x9270
movq 0x8(%rsp), %rdi
addq 0x10(%rsp), %rdi
andl $0x4, %ebp
testq %rbp, %rbp
je 0xffcc9
xorl %esi, %esi
movq %rbp, %rdx
callq 0x9270
movq 0x48(%r15), %rdi
movslq 0xc(%r15), %rbp
cmpq $0x8, %rbp
jb 0xffd01
movq %rbp, %rdx
andq $-0x8, %rdx
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x9270
movq 0x8(%rsp), %rdi
addq 0x10(%rsp), %rdi
andl $0x7, %ebp
testq %rbp, %rbp
je 0xffd10
xorl %esi, %esi
movq %rbp, %rdx
callq 0x9270
cmpl $0x0, 0xc(%r15)
jle 0xffd39
xorl %eax, %eax
movabsq $-0x600000000a0001, %rcx # imm = 0xFF9FFFFFFFF5FFFF
movq (%r15), %rdx
movq (%rdx,%rax,8), %rdx
andq %rcx, (%rdx)
incq %rax
movslq 0xc(%r15), %rdx
cmpq %rdx, %rax
jl 0xffd23
movl $0x0, 0xc(%r15)
movl $0x0, 0x10(%r15)
movb $0x0, 0x18(%r15)
movq 0x10(%r13), %rsi
movq 0x10(%r12), %rdx
movzbl (%rsi), %eax
leaq 0x5b15f(%rip), %r8      # 0x15aec0
movq %r14, %rdi
movq %r15, %rcx
callq *(%r8,%rax,8)
testb %al, %al
je 0xffc36
movq 0x18(%r13), %rax
cmpq 0x18(%r12), %rax
je 0xffc38
testq %r15, %r15
jne 0xffd92
movq %r14, %rdi
callq 0x9c66c
movq %rax, %r15
movq 0x18(%r13), %rsi
movq 0x18(%r12), %rdx
movzbl (%rsi), %eax
leaq 0x5b11b(%rip), %r8      # 0x15aec0
movq %r14, %rdi
movq %r15, %rcx
callq *(%r8,%rax,8)
testb %al, %al
je 0xffc36
jmp 0xffc38
// File: /workspace/github_c_makefile_star2_O1/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 0xfff1a
movb (%rsi), %cl
cmpb (%rdx), %cl
jne 0xfff8e
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 0xfff1d
andb %r9b, %al
retq
movb $0x1, %al
retq
movl 0x4(%r8), %eax
cmpl 0x4(%rdi), %eax
jne 0xfff8e
testl %eax, %eax
je 0xfff6e
cmpl $0x2, %eax
je 0xfff5f
cmpl $0x1, %eax
jne 0xfff8e
movq 0x20(%rsi), %rax
cmpq 0x20(%rdx), %rax
jne 0xfff8e
movq 0x18(%rsi), %r8
cmpq 0x18(%rdx), %r8
jne 0xfff8e
movq 0x10(%rsi), %rdi
cmpb $0x23, %cl
cmoveq %r8, %rax
movq 0x10(%rdx), %rsi
movq %rax, %rdx
jmp 0x9253a
cmpb $0x23, %cl
jne 0xfff91
movq 0x50(%r8), %rax
cmpq 0x50(%rdi), %rax
jmp 0xfff99
cmpb $0x23, %cl
jne 0xfff8e
movq 0x20(%rsi), %rax
cmpq 0x20(%rdx), %rax
jne 0xfff8e
movq 0x10(%rdi), %rsi
movq 0x10(%r8), %rdi
movq 0x30(%r8), %rdx
jmp 0x9253a
xorl %eax, %eax
retq
movq 0x58(%r8), %rax
cmpq 0x58(%rdi), %rax
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdx, %rsi
je 0x1000a1
movq %rdx, %r15
movq %rsi, %r12
movb (%rsi), %al
cmpb (%rdx), %al
jne 0x1000f3
movq %rcx, %rbx
movq %rdi, %r14
testb $0x40, 0x3(%r15)
je 0x1000aa
cmpb $0x1, 0x24c(%r14)
jne 0x1000aa
testb $0x40, 0x3(%r12)
je 0x1000aa
movq %r14, %rdi
movq %r12, %rsi
callq 0x9a55
movq 0x1100(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
movq %rax, %r13
movq 0x128(%r14), %rbp
cmpq %rbp, %rax
je 0x1000a5
movq 0x90(%r14), %rax
movq 0x110(%r14), %rdx
cmpq 0x98(%r14), %rax
ja 0x100043
movq %r14, %rdi
movq %rdx, (%rsp)
callq 0xb389
movq (%rsp), %rdx
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq 0x90(%r14), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r12, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %r14, %rdi
movq %r13, %rsi
callq 0xbd41
cmpq %rax, 0x120(%r14)
setne %al
jmp 0x1000a5
movb $0x1, %al
jmp 0x1000f5
cmpq %rbp, %r13
jne 0x1000f5
movq 0x8(%r12), %rsi
movq 0x8(%r15), %rdx
movzbl (%rsi), %eax
leaq 0x5ae03(%rip), %r13     # 0x15aec0
movq %r14, %rdi
movq %rbx, %rcx
callq *(%r13,%rax,8)
testb %al, %al
je 0x1000f3
movq 0x10(%r12), %rsi
movq 0x10(%r15), %rdx
movzbl (%rsi), %eax
movq (%r13,%rax,8), %rax
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
andb $0x1, %al
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: 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdx, %rsi
je 0x10020a
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testb $0x40, 0x3(%rsi)
je 0x10021b
cmpb $0x1, 0x24c(%r12)
jne 0x10021b
movq %r12, %rdi
movq %r15, %rsi
callq 0x9a55
movq 0x1100(%r12), %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0x99ef
movq %rax, %r13
movq 0x128(%r12), %rax
cmpq %rax, %r13
je 0x100212
movq %rax, (%rsp)
movq 0x90(%r12), %rax
movq 0x110(%r12), %rbp
cmpq 0x98(%r12), %rax
ja 0x1001a2
movq %r12, %rdi
callq 0xb389
movq 0x90(%r12), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r12)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%r12), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%r12)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r15, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %r12, %rdi
movq %r13, %rsi
callq 0xbd41
cmpq %rax, 0x120(%r12)
setne %bpl
movq (%rsp), %rax
jmp 0x100212
movb $0x1, %bpl
jmp 0x1002f8
cmpq %rax, %r13
jne 0x1002f8
testb $0x40, 0x3(%r14)
je 0x10030d
cmpb $0x1, 0x24c(%r12)
jne 0x10030d
movq %r12, %rdi
movq %r14, %rsi
callq 0x9a55
movq 0x1100(%r12), %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0x99ef
movq %rax, %r13
movq 0x128(%r12), %rax
cmpq %rax, %r13
je 0x1002f3
movq %rax, (%rsp)
movq 0x90(%r12), %rax
movq 0x110(%r12), %rbp
cmpq 0x98(%r12), %rax
ja 0x10028d
movq %r12, %rdi
callq 0xb389
movq 0x90(%r12), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r12)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%r12), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%r12)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r14, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %r12, %rdi
movq %r13, %rsi
callq 0xbd41
cmpq %rax, 0x120(%r12)
setne %bpl
movq (%rsp), %rax
cmpq %rax, %r13
je 0x10030d
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x101788
// File: /workspace/github_c_makefile_star2_O1/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 0x100ce8
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
sete %al
jmp 0x100d50
movq %rdi, %rbx
leaq 0x51cbe(%rip), %rcx     # 0x1529b0
cmpb $0x1, (%rax,%rcx)
jne 0x100d2e
cvtsi2sdq 0x8(%rsi), %xmm0
cmpl $0xd, %eax
je 0x100d5f
movq 0x51d26(%rip), %rdi     # 0x152a30
leaq 0x12257(%rip), %rax     # 0x112f68
movq %rdx, %rsi
movq %rax, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0xe212
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
jmp 0x100d64
cmpl $0xe, %eax
jne 0x100d4e
movsd 0x10(%rdx), %xmm0
andpd 0x12090(%rip), %xmm0    # 0x112dd0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0x100d56
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%rsi), %xmm0
movsd 0x8(%rdx), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x101c6c
// File: /workspace/github_c_makefile_star2_O1/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 0x51c28(%rip), %rcx     # 0x1529b0
cmpb $0x1, (%rax,%rcx)
jne 0x100dc3
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
movq %rcx, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rdx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cmpb $0xd, %al
jne 0x100e28
movsd 0x8(%r14), %xmm1
jmp 0x100e4b
cmpb $0xe, %al
jne 0x100e1e
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 0x101c6c
testb %al, %al
je 0x100e1e
movsd 0x10(%r14), %xmm0
andpd 0x11fc3(%rip), %xmm0    # 0x112dd0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
setae %al
jmp 0x100e20
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x51c01(%rip), %rdi     # 0x152a30
leaq 0x12132(%rip), %rdx     # 0x112f68
movq %r14, %rsi
movsd %xmm0, (%rsp)
callq 0xe212
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
jmp 0x101c6c
// File: /workspace/github_c_makefile_star2_O1/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 0x51b44(%rip), %rcx     # 0x1529b0
cmpb $0x1, (%rax,%rcx)
jne 0x100ea5
movsd 0x8(%rsi), %xmm0
cmpb $0xd, %al
je 0x100ed1
movq 0x51bae(%rip), %rdi     # 0x152a30
leaq 0x120df(%rip), %rax     # 0x112f68
movq %rdx, %rsi
movq %rax, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0xe212
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
jmp 0x100ed6
cmpb $0xe, %al
jne 0x100ec4
movsd 0x10(%rdx), %xmm0
andpd 0x11f1a(%rip), %xmm0    # 0x112dd0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0x100ecc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movsd 0x8(%rsi), %xmm0
movsd 0x8(%rdx), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x101c6c
// File: /workspace/github_c_makefile_star2_O1/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 0x100f33
movsd 0x8(%r15), %xmm0
movsd 0x8(%r14), %xmm1
movq %rbx, %rdi
callq 0x101c6c
testb %al, %al
je 0x100f5c
movsd 0x10(%r15), %xmm0
movsd 0x10(%r14), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x101c6c
leaq 0x51a76(%rip), %rcx     # 0x1529b0
cmpb $0x1, (%rax,%rcx)
jne 0x100f5c
movsd 0x10(%r15), %xmm0
andpd 0x11e82(%rip), %xmm0    # 0x112dd0
movsd 0x260(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jae 0x100f68
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd 0x8(%r15), %xmm0
cmpl $0xd, %eax
jne 0x100f7b
movsd 0x8(%r14), %xmm1
jmp 0x100f22
movq 0x51aae(%rip), %rdi     # 0x152a30
leaq 0x11fdf(%rip), %rdx     # 0x112f68
movq %r14, %rsi
movsd %xmm0, 0x8(%rsp)
callq 0xe212
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
jmp 0x100f22
// File: /workspace/github_c_makefile_star2_O1/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 0x100fbf
movq %r14, %rdi
callq 0x9cf49
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_O1/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 0x101b69
movq 0x10(%rdx), %rcx
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
cmpq $0x1, %rcx
je 0x101b71
testq %rax, %rax
je 0x101b82
cmpq 0x10(%rax), %rcx
jne 0x101b82
testq %rcx, %rcx
jle 0x101b7f
movq (%rdx), %rdx
movq (%rax), %rsi
decq %rcx
xorl %edi, %edi
movq (%rdx,%rdi,8), %rax
cmpq (%rsi,%rdi,8), %rax
sete %al
jne 0x101b68
leaq 0x1(%rdi), %r8
cmpq %rdi, %rcx
movq %r8, %rdi
jne 0x101b4f
retq
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x101b7f
cmpq $0x1, 0x10(%rax)
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x8, %rdx
jge 0x101bb3
xorl %ecx, %ecx
movb $0x1, %al
cmpq %rdx, %rcx
jge 0x101bb2
decq %rdx
movq (%rdi,%rcx,8), %r8
movq (%rsi,%rcx,8), %r9
cmpq %r9, %r8
sete %al
cmpq %rcx, %rdx
je 0x101bb2
incq %rcx
cmpq %r9, %r8
je 0x101b97
retq
leaq -0x8(%rdx), %rax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %r8
cmpq (%rsi,%rcx,8), %r8
jne 0x101c25
movq 0x8(%rdi,%rcx,8), %r8
cmpq 0x8(%rsi,%rcx,8), %r8
jne 0x101c25
movq 0x10(%rdi,%rcx,8), %r8
cmpq 0x10(%rsi,%rcx,8), %r8
jne 0x101c25
movq 0x18(%rdi,%rcx,8), %r8
cmpq 0x18(%rsi,%rcx,8), %r8
jne 0x101c25
movq 0x20(%rdi,%rcx,8), %r8
cmpq 0x20(%rsi,%rcx,8), %r8
jne 0x101c25
movq 0x28(%rdi,%rcx,8), %r8
cmpq 0x28(%rsi,%rcx,8), %r8
jne 0x101c25
movq 0x30(%rdi,%rcx,8), %r8
cmpq 0x30(%rsi,%rcx,8), %r8
jne 0x101c25
movq 0x38(%rdi,%rcx,8), %r8
cmpq 0x38(%rsi,%rcx,8), %r8
jne 0x101c25
addq $0x8, %rcx
cmpq %rax, %rcx
jle 0x101bb9
jmp 0x101b8d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb $0x1, %al
cmpq %rsi, %rdi
je 0x101c68
movb (%rdi), %cl
cmpb (%rsi), %cl
jne 0x101c69
movq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
jne 0x101c69
testq %rcx, %rcx
jle 0x101c68
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rsi
decq %rcx
xorl %edi, %edi
movb (%rdx,%rdi), %al
cmpb (%rsi,%rdi), %al
sete %al
jne 0x101c68
leaq 0x1(%rdi), %r8
cmpq %rdi, %rcx
movq %r8, %rdi
jne 0x101c51
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x101c76
jnp 0x101cc8
movsd 0x260(%rdi), %xmm3
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
andpd 0x11142(%rip), %xmm2    # 0x112dd0
ucomisd %xmm2, %xmm3
jae 0x101cc8
ucomisd %xmm1, %xmm0
jp 0x101ccb
movapd 0x1111e(%rip), %xmm1    # 0x112dc0
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
mulsd %xmm1, %xmm3
movsd 0xd37a(%rip), %xmm0     # 0x10f030
cmpltpd %xmm1, %xmm0
cmpltpd %xmm3, %xmm2
andpd %xmm0, %xmm2
movd %xmm2, %eax
andb $0x1, %al
retq
ucomisd %xmm0, %xmm0
jp 0x101cd5
xorl %eax, %eax
jmp 0x101cc8
ucomisd %xmm1, %xmm1
setp %al
jmp 0x101cc8
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x9360
movabsq $0x4000000001000013, %rcx # imm = 0x4000000001000013
movq %rcx, (%rax)
testq %rbx, %rbx
je 0x101d1f
cmpb $0x0, (%rbx)
je 0x101d1f
movq $-0x1, %rdx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%rbx,%rdx)
movq %rcx, %rdx
jne 0x101d0f
jmp 0x101d21
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9e8b
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0xda02c
movq %r14, %rdi
callq 0xda0e5
movq %rax, 0x20(%r14)
movq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9e8b
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xda02c
movq %r14, %rdi
callq 0xda20f
movq %rax, 0x20(%r14)
movq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9e8b
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdbb0c
movq %r14, %rdi
callq 0xdbc2e
movq %rax, 0x20(%r14)
movq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9e8b
movq %rax, 0x2e8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdc67a
movq %r14, %rdi
callq 0xdc787
movq %rax, 0x20(%r14)
movq $0x0, 0x2d0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10201c
cmpl $0x1, %ecx
jne 0x102020
movq 0x8(%rax), %rcx
cmpq 0x17b0(%rdi), %rcx
jne 0x10201c
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10212e
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 0x1020bc
movq 0x570(%rbx), %rax
movq %r14, 0x8(%rax)
movq 0x578(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x570(%rbx), %rax
jmp 0x102122
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x1020db
movq %rbx, %rdi
callq 0xb389
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_O1/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 0x102519
movl $0x2, 0x20(%rax)
movq 0x10(%rax), %rcx
cmpq 0x120(%rdi), %rcx
je 0x102519
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 0x10b83
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq %rsi, 0x120(%rdi)
je 0x102550
testb $0x1, 0x3(%rsi)
jne 0x102550
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
callq *0x48(%rax)
movq 0x38(%rbx), %rax
movq 0x10(%rax), %rax
movq -0x8(%rax,%r14,8), %rax
cmpq 0x140(%rbx), %rax
je 0x10256d
movq %rax, 0x188(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x38(%rdi), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rcx,%rsi,8), %rcx
cmpb $0x23, (%rcx)
jne 0x102698
cmpq %rcx, 0x170(%rdi)
jne 0x10267f
movl 0x184(%rdi), %ecx
testl %ecx, %ecx
je 0x10266e
decl %ecx
movl %ecx, 0x184(%rdi)
shlq $0x3, %rcx
addq 0x178(%rdi), %rcx
jmp 0x102675
leaq 0x1c8(%rdi), %rcx
movq (%rcx), %rcx
movq %rcx, 0x170(%rdi)
pushq %rax
movq 0x10(%rax), %rax
movq -0x8(%rax,%rsi,8), %rsi
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
callq *0x48(%rax)
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1027d2
movq %rdx, %r14
testq %rdx, %rdx
jle 0x1027c6
xorl %r15d, %r15d
movq 0x4b820(%rip), %r12     # 0x14dfd0
movsbl (%rbx,%r15), %edi
movq (%r12), %rsi
callq 0x9300
incq %r15
cmpq %r15, %r14
jne 0x1027b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4b7f7(%rip), %rax     # 0x14dfd0
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9250
// File: /workspace/github_c_makefile_star2_O1/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 0x102861
movq %rdx, %r14
testq %rdx, %rdx
jle 0x102855
xorl %r15d, %r15d
movq 0x4b7b9(%rip), %r12     # 0x14dff8
movsbl (%rbx,%r15), %edi
movq (%r12), %rsi
callq 0x9300
incq %r15
cmpq %r15, %r14
jne 0x10283f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x4b790(%rip), %rax     # 0x14dff8
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9250