LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: ceiling_i_7d
static s7_int ceiling_i_7d(s7_scheme *sc, s7_double x)
    {
        if (is_NaN(x))
            simple_out_of_range(sc, sc->ceiling_symbol, wrap_real(sc, x), its_nan_string);
        if ((is_inf(x)) ||
                (x > REAL_TO_INT_LIMIT) ||
                (x < -REAL_TO_INT_LIMIT))
            simple_out_of_range(sc, sc->ceiling_symbol, wrap_real(sc, x), its_too_large_string);
        return((s7_int)ceil(x));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x13860
testb $0x1, %al
jne 0xb2890
jmp 0xb28d8
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0xda8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0x1bc2f0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
movq 0x17291d(%rip), %rcx    # 0x2251f0
callq 0x45240
movsd 0x28(%rsp), %xmm1
movaps %xmm1, %xmm0
movaps 0x12f1b8(%rip), %xmm2   # 0x1e1aa0
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x12f066(%rip), %xmm1   # 0x1e1970
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
jne 0xb2946
movsd 0x28(%rsp), %xmm0
movsd 0x12f0f0(%rip), %xmm1   # 0x1e1a20
ucomisd %xmm1, %xmm0
ja 0xb2946
movsd 0x12f0ea(%rip), %xmm0   # 0x1e1a28
ucomisd 0x28(%rsp), %xmm0
jbe 0xb298e
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0xda8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0x1bc2f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movq 0x167be7(%rip), %rcx    # 0x21a570
callq 0x45240
movsd 0x28(%rsp), %xmm0
callq 0x96c0
cvttsd2si %xmm0, %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: multiply_i_iii
static s7_int multiply_i_iii(s7_int i1, s7_int i2, s7_int i3)
    {
#if HAVE_OVERFLOW_CHECKS
        s7_int val1, val2;
        if (multiply_overflow(i1, i2, &val1))
            return(s7_int_max);
        if (multiply_overflow(val1, i3, &val2))
            return(s7_int_max);
        return(val2);
#else
        return(i1 * i2 * i3);
#endif
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rcx
imulq -0x18(%rsp), %rcx
seto %al
movq %rcx, -0x28(%rsp)
testb $0x1, %al
jne 0xb6668
jmp 0xb6676
movq 0x1640c9(%rip), %rax    # 0x21a738
movq %rax, -0x8(%rsp)
jmp 0xb66a7
movq -0x28(%rsp), %rcx
imulq -0x20(%rsp), %rcx
seto %al
movq %rcx, -0x30(%rsp)
testb $0x1, %al
jne 0xb668f
jmp 0xb669d
movq 0x1640a2(%rip), %rax    # 0x21a738
movq %rax, -0x8(%rsp)
jmp 0xb66a7
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: vector_to_list_p_p
static s7_pointer vector_to_list_p_p(s7_scheme *sc, s7_pointer p)
                {
                    s7_pointer val;
                    sc->temp7 = list_1(sc, p);
                    val = g_vector_to_list(sc, sc->temp7);
                    sc->temp7 = sc->nil;
                    return(val);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xb6cfd
movq 0x30(%rsp), %rdi
callq 0xc670
movq 0x30(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x528(%rax)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x528(%rax), %rsi
callq 0x995f0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x528(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: numerator_i_7p
static s7_int numerator_i_7p(s7_scheme *sc, s7_pointer p)
    {
        if (!is_rational(p))
            return(integer(method_or_bust_with_type_one_arg(sc, p, sc->numerator_symbol, list_1(sc, p), a_rational_string)));
        /* it is documented somewhere that if a method shadows a built-in, that method's signature (including return type) must match the built-in's */
        return(numerator(p));
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x163631(%rip), %rax    # 0x21a520
testb $0x1, (%rax,%rcx)
jne 0xb6fdd
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x1378(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xb6f5d
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x16e1db(%rip), %r8     # 0x2251a8
callq 0x1ba7e0
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0xb6feb
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: denominator_i_7p
static s7_int denominator_i_7p(s7_scheme *sc, s7_pointer p)
    {
        if (!is_rational(p))
            return(integer(method_or_bust_with_type_one_arg(sc, p, sc->denominator_symbol, list_1(sc, p), a_rational_string)));
        if (is_t_integer(p))
            return(1);
        return(denominator(p));
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x163501(%rip), %rax    # 0x21a520
testb $0x1, (%rax,%rcx)
jne 0xb710d
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0xe70(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xb708d
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x16e0ab(%rip), %r8     # 0x2251a8
callq 0x1ba7e0
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0xb7133
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xb7125
movq $0x1, 0x50(%rsp)
jmp 0xb7133
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: tree_leaves_i_7p
static s7_int tree_leaves_i_7p(s7_scheme *sc, s7_pointer p)
    {
        if ((sc->safety > NO_SAFETY) &&
                (tree_is_cyclic(sc, p)))
            s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-leaves: tree is cyclic", 27));
        return(tree_len(sc, p));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jle 0xb73f5
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f870
testb $0x1, %al
jne 0xb73b2
jmp 0xb73f5
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x1940(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x13cbda(%rip), %rsi    # 0x1f3fb3
movl $0x1b, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdc840
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_port_closed_b_7p
static bool is_port_closed_b_7p(s7_scheme *sc, s7_pointer x)
    {
        if ((is_input_port(x)) || (is_output_port(x)))
            return(port_is_closed(x));
        if ((x == sc->output_port) && (x == sc->F))
            return(false);
        simple_wrong_type_argument_with_type(sc, sc->is_port_closed_symbol, x, wrap_string(sc, "a port", 6));
        return(false);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0xb7738
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0xb774f
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movb 0x2(%rax), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xb77eb
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x188(%rcx), %rax
jne 0xb777c
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0xb777c
movb $0x0, 0x37(%rsp)
jmp 0xb77eb
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x1148(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x140(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x13bdf1(%rip), %rsi    # 0x1f35b2
movl $0x6, %edx
callq 0xb880
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rax, %r8
callq 0x14a60
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_char_whitespace_b_7p
static bool is_char_whitespace_b_7p(s7_scheme *sc, s7_pointer c)
    {
        if (s7_is_character(c))
            return(is_char_whitespace(c));
        if (has_active_methods(sc, c))
        {
            s7_pointer f;
            f = find_method(sc, find_let(sc, c), sc->is_char_whitespace_symbol);
            if (f != sc->undefined)
                return(is_true(sc, s7_apply_function(sc, f, cons(sc, c, sc->nil))));
        }
        simple_wrong_type_argument(sc, sc->is_char_whitespace_symbol, c, T_CHARACTER);
        return(false);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0xb7a2e
jmp 0xb7a41
movq 0x40(%rsp), %rax
movb 0x12(%rax), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0xb7bc3
movq 0x40(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0xb7b8c
movq 0x48(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0xb7b8c
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rax
movq 0x1030(%rax), %rdx
callq 0x98d0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0xb7b8a
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xb7b0b
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xda50
movq 0x48(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0xb7bc3
jmp 0xb7b8c
movq 0x48(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x1030(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x162a17(%rip), %r8     # 0x21a5d0
callq 0x14a60
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: iterator_is_at_end_b_7p
static bool iterator_is_at_end_b_7p(s7_scheme *sc, s7_pointer obj)
    {
        if (iter_ok(obj))
            return(false);
        if (!is_iterator(obj))
            simple_wrong_type_argument(sc, sc->iterator_is_at_end_symbol, obj, T_ITERATOR);
        return(true);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rcx
movabsq $0x80000000, %rax       # imm = 0x80000000
andq (%rcx), %rax
cmpq $0x0, %rax
je 0xb7c7b
movb $0x0, 0x17(%rsp)
jmp 0xb7cbd
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
je 0xb7cb8
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x11d0(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1629c5(%rip), %r8     # 0x21a678
callq 0x14a60
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_zero_b_7p
static bool is_zero_b_7p(s7_scheme *sc, s7_pointer p)
    {
#if WITH_GMP
        return(s7_is_zero(p));
#else
        if (is_t_integer(p))
            return(integer(p) == 0);
        if (is_t_real(p))
            return(real(p) == 0.0);
        if (!is_number(p))
            simple_wrong_type_argument_with_type(sc, sc->is_zero_symbol, p, a_number_string);
        return(false);
#endif
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xb7cfd
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xb7d75
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xb7d29
movq (%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xb7d75
movq (%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x162767(%rip), %rax    # 0x21a4a0
testb $0x1, (%rax,%rcx)
jne 0xb7d70
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x11c0(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x16d185(%rip), %r8     # 0x224ef0
callq 0x14a60
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_negative_b_7p
static bool is_negative_b_7p(s7_scheme *sc, s7_pointer p)
    {
#if WITH_GMP
        return(s7_is_negative(p));
#else
        if (is_t_integer(p))
            return(integer(p) < 0);
        if (is_t_real(p))
            return(real(p) < 0.0);
        if (!is_real(p))
            simple_wrong_type_argument(sc, sc->is_negative_symbol, p, T_REAL);
        return(numerator(p) < 0);
#endif
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xb7dad
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
setl %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xb7e29
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xb7dd0
movq (%rsp), %rax
xorps %xmm0, %xmm0
ucomisd 0x8(%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xb7e29
movq (%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x162700(%rip), %rax    # 0x21a4e0
testb $0x1, (%rax,%rcx)
jne 0xb7e17
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x1110(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x1627e6(%rip), %r8     # 0x21a5f8
callq 0x14a60
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
setl %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_positive_b_7p
static bool is_positive_b_7p(s7_scheme *sc, s7_pointer p)
    {
#if WITH_GMP
        return(s7_is_positive(p));
#else
        if (is_t_integer(p))
            return(integer(p) > 0);
        if (is_t_real(p))
            return(real(p) > 0.0);
        if (!is_real(p))
            simple_wrong_type_argument(sc, sc->is_positive_symbol, p, T_REAL);
        return(numerator(p) > 0);
#endif
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xb7e70
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
setg %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xb7ef0
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xb7e97
movq (%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xb7ef0
movq (%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x162639(%rip), %rax    # 0x21a4e0
testb $0x1, (%rax,%rcx)
jne 0xb7ede
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x1150(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x16271f(%rip), %r8     # 0x21a5f8
callq 0x14a60
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
setg %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: tree_set_memq_b_7pp
static bool tree_set_memq_b_7pp(s7_scheme *sc, s7_pointer syms, s7_pointer tree)
    {
        s7_pointer p;
        if (!is_pair(syms)) return(false);
        if (sc->safety > NO_SAFETY)
        {
            if (tree_is_cyclic(sc, syms))
                s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-set-memq: symbol list is cyclic", 36));
            if (tree_is_cyclic(sc, tree))
                s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-set-memq: tree is cyclic", 29));
        }
        clear_symbol_list(sc);
        for (p = syms; is_pair(p); p = cdr(p))
            if (is_symbol(car(p)))
                add_symbol_to_list(sc, car(p));
        return(tree_set_memq(sc, tree));
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xb80da
movb $0x0, 0x47(%rsp)
jmp 0xb8209
movq 0x38(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jle 0xb819d
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2f870
testb $0x1, %al
jne 0xb8102
jmp 0xb8145
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x1940(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x13bea6(%rip), %rsi    # 0x1f3fcf
movl $0x24, %edx
callq 0xb880
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2f870
testb $0x1, %al
jne 0xb815a
jmp 0xb819b
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq 0x1940(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x1377c5(%rip), %rsi    # 0x1ef945
movl $0x1d, %edx
callq 0xb880
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
jmp 0xb819d
movq 0x38(%rsp), %rdi
callq 0xdd1b0
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xb81f4
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0xb81e2
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xde160
jmp 0xb81e4
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xb81b1
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x15c8c0
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: integer_to_char_p_p
static s7_pointer integer_to_char_p_p(s7_scheme *sc, s7_pointer x)
    {
        s7_int ind;
        if (!s7_is_integer(x))
            return(method_or_bust_one_arg(sc, x, sc->integer_to_char_symbol, list_1(sc, x), T_INTEGER));
        ind = s7_integer(x);
        if ((ind >= 0) && (ind < NUM_CHARS))
            return(s7_make_character(sc, (uint8_t)ind));
        return(s7_out_of_range_error(sc, "integer->char", 1, x, "it doen't fit in an unsigned byte"));
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0xb855d
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0xfc8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xb84e3
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movl $0xb, %r8d
callq 0xcfd30
movq %rax, 0x50(%rsp)
jmp 0xb85bf
movq 0x40(%rsp), %rdi
callq 0x10790
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jl 0xb8598
cmpq $0x100, 0x38(%rsp)      # imm = 0x100
jge 0xb8598
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rax
movzbl %al, %esi
callq 0x14410
movq %rax, 0x50(%rsp)
jmp 0xb85bf
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x12ee6a(%rip), %rsi    # 0x1e7413
movl $0x1, %edx
leaq 0x13ba3f(%rip), %r8     # 0x1f3ff4
callq 0x45070
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: tree_leaves_p_p
static s7_pointer tree_leaves_p_p(s7_scheme *sc, s7_pointer tree)
    {
        if ((sc->safety > NO_SAFETY) && /* repeat code to avoid extra call overhead */
                (tree_is_cyclic(sc, tree)))
            s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-leaves: tree is cyclic", 27));
        return(s7_make_integer(sc, tree_len(sc, tree)));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x6a0(%rax)
jle 0xb8c75
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f870
testb $0x1, %al
jne 0xb8c32
jmp 0xb8c75
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x1940(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x13b35a(%rip), %rsi    # 0x1f3fb3
movl $0x1b, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdc840
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x120f0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: pair_line_number_p_p
static s7_pointer pair_line_number_p_p(s7_scheme *sc, s7_pointer p)
    {
        if (!is_pair(p))
            return(method_or_bust_one_arg(sc, p, sc->pair_line_number_symbol, set_plist_1(sc, p), T_PAIR));
        if (has_line_number(p))
            return(make_integer(sc, pair_line_number(p)));
        return(sc->F);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xb8d56
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x13d0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x35ea0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
movl $0x1, %r8d
callq 0xcfd30
movq %rax, 0x50(%rsp)
jmp 0xb8e3e
movq 0x40(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0xb8e2d
movq 0x40(%rsp), %rax
movl 0x2c(%rax), %eax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0xb8da2
movq 0x38(%rsp), %rcx
leaq 0x15d6e8(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xb8e18
jmp 0xb8da4
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xb8dc8
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0xb, (%rax)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xb8e3e
movq 0x48(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_int_vector_p_ii
static s7_pointer make_int_vector_p_ii(s7_scheme *sc, s7_int len, s7_int init)
                {
                    s7_pointer x;
                    x = make_vector_1(sc, len, NOT_FILLED, T_INT_VECTOR);
                    int_vector_fill(sc, x, init);
                    add_vector(sc, x);
                    return(x);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
movl $0x16, %ecx
callq 0x333c0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xd8330
movq 0x20(%rsp), %rax
movq 0x740(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11230
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_zero_p_p
static s7_pointer is_zero_p_p(s7_scheme *sc, s7_pointer p)
    {
#if WITH_GMP
        return(make_boolean(sc, s7_is_zero(p)));
#else
        if (is_t_integer(p))
            return(make_boolean(sc, integer(p) == 0));
        if (is_t_real(p))
            return(make_boolean(sc, real(p) == 0.0));
        if (!is_number(p))
            simple_wrong_type_argument_with_type(sc, sc->is_zero_symbol, p, a_number_string);
        return(sc->F);
#endif
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xb9b4a
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xb9b2a
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xb9b3b
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xb9bf3
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xb9b99
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb9b7e
jp 0xb9b7e
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0xb9b8e
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xb9bf3
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1608f6(%rip), %rax    # 0x21a4a0
testb $0x1, (%rax,%rcx)
jne 0xb9be2
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x11c0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x16b313(%rip), %r8     # 0x224ef0
callq 0x14a60
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_positive_p_p
static s7_pointer is_positive_p_p(s7_scheme *sc, s7_pointer p)
    {
#if WITH_GMP
        return(make_boolean(sc, s7_is_positive(p)));
#else
        if (is_t_integer(p))
            return((integer(p) > 0) ? sc->T : sc->F);
        if (is_t_real(p))
            return((real(p) > 0.0) ? sc->T : sc->F);
        if (!is_real(p))
            simple_wrong_type_argument(sc, sc->is_positive_symbol, p, T_REAL);
        return((numerator(p) > 0) ? sc->T : sc->F);
#endif
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xb9c5a
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jle 0xb9c3a
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xb9c4b
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xb9d30
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xb9cad
movq 0x20(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xb9c8d
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xb9c9e
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xb9d30
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x160822(%rip), %rax    # 0x21a4e0
testb $0x1, (%rax,%rcx)
jne 0xb9cf6
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x1150(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x160907(%rip), %r8     # 0x21a5f8
callq 0x14a60
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jle 0xb9d15
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xb9d26
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_negative_p_p
static s7_pointer is_negative_p_p(s7_scheme *sc, s7_pointer x)
    {
        switch (type(x))
        {
            case T_INTEGER:     return(make_boolean(sc, integer(x) < 0));
            case T_RATIO:       return(make_boolean(sc, numerator(x) < 0));
            case T_REAL:        return(make_boolean(sc, real(x) < 0.0));
#if WITH_GMP
            case T_BIG_INTEGER: return(make_boolean(sc, (mpz_cmp_ui(big_integer(x), 0) < 0)));
            case T_BIG_RATIO:   return(make_boolean(sc, (mpq_cmp_ui(big_ratio(x), 0, 1) < 0)));
            case T_BIG_REAL:    return(make_boolean(sc, (mpfr_cmp_ui(big_real(x), 0) < 0)));
#endif
            default:
                                return(method_or_bust_one_arg(sc, x, sc->is_negative_symbol, list_1(sc, x), T_REAL));
        }
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x3c(%rsp)
subl $0xb, %eax
je 0xb9d7e
jmp 0xb9d61
movl 0x3c(%rsp), %eax
subl $0xc, %eax
je 0xb9dbd
jmp 0xb9d6c
movl 0x3c(%rsp), %eax
subl $0xd, %eax
je 0xb9dfc
jmp 0xb9e3e
movq 0x60(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jge 0xb9d9d
movq 0x68(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xb9dae
movq 0x68(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0xb9f1b
movq 0x60(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jge 0xb9ddc
movq 0x68(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0xb9ded
movq 0x68(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0xb9f1b
movq 0x60(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd 0x8(%rax), %xmm0
jbe 0xb9e1e
movq 0x68(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xb9e2f
movq 0x68(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0xb9f1b
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0x1110(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xb9ea2
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x48(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movl $0xd, %r8d
callq 0xcfd30
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: logbit_b_ii
static bool logbit_b_ii(s7_int i1, s7_int i2)
    {
        if (i2 < 0)
        {
            /* no b_7ii_t so fallback on cur_sc, etc -- kinda ugly */
            out_of_range(cur_sc, cur_sc->logbit_symbol, small_int(2), make_integer(cur_sc, i1), its_negative_string);
            return(false);
        }
        if (i2 >= s7_int_bits)
            return(i1 < 0);
        return((((int64_t)(1LL << (int64_t)i2)) & (int64_t)i1) != 0);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jge 0xba108
movq 0x16055f(%rip), %rax    # 0x21a560
movq %rax, 0x8(%rsp)
movq 0x160553(%rip), %rax    # 0x21a560
movq 0x12a0(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x15c46c(%rip), %rax    # 0x216490
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0xba05a
movq 0x38(%rsp), %rcx
leaq 0x15c430(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xba0d8
jmp 0xba05c
movq 0x1604fd(%rip), %rax    # 0x21a560
movq 0x90(%rax), %rax
movq 0x1604ef(%rip), %rcx    # 0x21a560
cmpq 0x98(%rcx), %rax
ja 0xba086
movq 0x1604df(%rip), %rdi    # 0x21a560
callq 0xc670
movq 0x1604d3(%rip), %rcx    # 0x21a560
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0xb, (%rax)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movq 0x16047c(%rip), %r8     # 0x21a578
callq 0x13880
movb $0x0, 0x57(%rsp)
jmp 0xba149
movq 0x40(%rsp), %rax
movslq 0x16067c(%rip), %rcx    # 0x21a790
cmpq %rcx, %rax
jl 0xba12a
cmpq $0x0, 0x48(%rsp)
setl %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0xba149
movq 0x40(%rsp), %rcx
movl $0x1, %eax
shlq %cl, %rax
andq 0x48(%rsp), %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: logbit_b_7pp
static bool logbit_b_7pp(s7_scheme *sc, s7_pointer p1, s7_pointer p2)
    {
        if (is_t_integer(p1))
        {
            if (is_t_integer(p2))
                return(logbit_b_ii(integer(p1), integer(p2)));
            simple_wrong_type_argument(sc, sc->logbit_symbol, p2, T_INTEGER);
        }
        simple_wrong_type_argument(sc, sc->logbit_symbol, p1, T_INTEGER);
        return(false);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xba37e
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xba34c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xb9fe0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xba3b5
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x12a0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x16026f(%rip), %r8     # 0x21a5e8
callq 0x14a60
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x12a0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x16023d(%rip), %r8     # 0x21a5e8
callq 0x14a60
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: num_eq_p_pi
static s7_pointer num_eq_p_pi(s7_scheme *sc, s7_pointer p1, s7_int p2)
    {
        if (is_t_integer(p1))
            return((integer(p1) == p2) ? sc->T : sc->F);
        if (is_t_real(p1))
            return((real(p1) == p2) ? sc->T : sc->F);
        if (is_number(p1))
            return(sc->F);
        return(wrong_type_argument_with_type(sc, sc->num_eq_symbol, 1, p1, a_number_string));
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xba423
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x48(%rsp), %rax
jne 0xba403
movq 0x58(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xba414
movq 0x58(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xba5a8
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xba47c
movq 0x50(%rsp), %rax
movsd 0x8(%rax), %xmm0
cvtsi2sdq 0x48(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jne 0xba45c
jp 0xba45c
movq 0x58(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xba46d
movq 0x58(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xba5a8
movq 0x50(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x160013(%rip), %rax    # 0x21a4a0
testb $0x1, (%rax,%rcx)
je 0xba4a9
movq 0x58(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x60(%rsp)
jmp 0xba5a8
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq 0xea0(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x1, 0x40(%rsp)
movq 0x40(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0xba4f8
movq 0x40(%rsp), %rcx
leaq 0x15bf92(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xba56e
jmp 0xba4fa
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xba51e
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0xb, (%rax)
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x16a952(%rip), %r9     # 0x224ef0
callq 0xc560
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: num_eq_b_pi
static bool num_eq_b_pi(s7_scheme *sc, s7_pointer x, s7_int y)
    {
        if (is_t_integer(x))
            return(integer(x) == y);

        switch (type(x))
        {
            case T_INTEGER: return(integer(x) == y);
            case T_RATIO:   return(false);
            case T_REAL:    return(real(x) == y);
            case T_COMPLEX: return(false);
            default:
                            simple_wrong_type_argument_with_type(sc, sc->num_eq_symbol, x, a_number_string);
        }
        return(false);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xbc80c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbc8b9
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
addl $-0xb, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3, %eax
ja 0xbc882
movq (%rsp), %rax
leaq 0x12274f(%rip), %rcx    # 0x1def7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbc8b9
movb $0x0, 0x27(%rsp)
jmp 0xbc8b9
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
cvtsi2sdq 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbc8b9
movb $0x0, 0x27(%rsp)
jmp 0xbc8b9
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xea0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x168641(%rip), %r8     # 0x224ef0
callq 0x14a60
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: lt_b_pi
static bool lt_b_pi(s7_scheme *sc, s7_pointer p1, s7_int p2)
    {
        if (is_t_integer(p1)) return(integer(p1) < p2);
        if (is_t_real(p1))  return(real(p1) < p2);
        if (is_t_ratio(p1)) return(ratio_lt_pi(p1, p2));
        simple_wrong_type_argument(sc, sc->lt_symbol, p1, T_REAL);
        return(false);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xbc90c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
setl %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbc994
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xbc939
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm1
cvtsi2sdq 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbc994
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xc, %eax
jne 0xbc95d
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x164460
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbc994
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x12c0(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x15dc6e(%rip), %r8     # 0x21a5f8
callq 0x14a60
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: leq_b_pi
static bool leq_b_pi(s7_scheme *sc, s7_pointer p1, s7_int p2)
    {
        if (is_t_integer(p1)) return(integer(p1) <= p2);
        if (is_t_real(p1))  return(real(p1) <= p2);
        if (is_t_ratio(p1)) return(ratio_leq_pi(p1, p2));
        simple_wrong_type_argument(sc, sc->leq_symbol, p1, T_REAL);
        return(false);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xbc9dc
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
setle %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbca64
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xbca09
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm1
cvtsi2sdq 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbca64
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xc, %eax
jne 0xbca2d
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1645a0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbca64
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x1220(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x15db9e(%rip), %r8     # 0x21a5f8
callq 0x14a60
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: gt_b_pi
static bool gt_b_pi(s7_scheme *sc, s7_pointer p1, s7_int p2)
    {
        if (is_t_integer(p1)) return(integer(p1) > p2);
        if (is_t_real(p1))  return(real(p1) > p2);
        if (is_t_ratio(p1)) return(!ratio_leq_pi(p1, p2));
        simple_wrong_type_argument(sc, sc->gt_symbol, p1, T_REAL);
        return(false);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xbcaac
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
setg %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbcb36
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xbcad9
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
cvtsi2sdq 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbcb36
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xc, %eax
jne 0xbcaff
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1645a0
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbcb36
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xf58(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x15dacc(%rip), %r8     # 0x21a5f8
callq 0x14a60
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: geq_b_pi
static bool geq_b_pi(s7_scheme *sc, s7_pointer p1, s7_int p2)
    {
        if (is_t_integer(p1)) return(integer(p1) >= p2);
        if (is_t_real(p1))  return(real(p1) >= p2);
        if (is_t_ratio(p1)) return(!ratio_lt_pi(p1, p2));
        simple_wrong_type_argument(sc, sc->geq_symbol, p1, T_REAL);
        return(false);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0xbcb8c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rsp), %rax
setge %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbcc16
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xbcbb9
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
cvtsi2sdq 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbcc16
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xc, %eax
jne 0xbcbdf
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x164460
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xbcc16
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0xf48(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x15d9ec(%rip), %r8     # 0x21a5f8
callq 0x14a60
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_s7_let_ref_fallback
static s7_pointer g_s7_let_ref_fallback(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer sym;

                    sym = cadr(args);
                    if (!is_symbol(sym))
                        return(simple_wrong_type_argument(sc, sc->let_ref_symbol, sym, T_SYMBOL));
                    if (is_keyword(sym))
                        sym = keyword_symbol(sym);
                    return(s7_let_field(sc, sym));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0xbe566
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x1230(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x15c086(%rip), %r8     # 0x21a5e0
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0xbe5a3
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xbe58f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x19b1f0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)