LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_leq_ti
static s7_pointer fx_leq_ti(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    if (is_t_integer(x))
                        return(make_boolean(sc, integer(x) <= integer(opt2_con(cdr(arg)))));
                    set_car(sc->t2_1, x);
                    set_car(sc->t2_2, opt2_con(cdr(arg)));
                    return(g_leq_xi(sc, sc->t2_1));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xb, (%rax)
jne 0xa3e6d
movq 0x8(%rax), %rax
movq 0x10(%rsi), %rcx
movq 0x20(%rcx), %rcx
xorl %edx, %edx
cmpq 0x8(%rcx), %rax
setg %dl
movq 0x118(%rdi,%rdx,8), %rax
retq
movq 0x570(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x578(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rdi), %rsi
jmp 0xa3dbf
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_greater_xi
static s7_pointer g_greater_xi(s7_scheme *sc, s7_pointer args)
    {
        s7_int y;
        s7_pointer x;

        x = car(args);
        y = integer(cadr(args));

        if (type(x) == T_INTEGER)
            return(make_boolean(sc, integer(x) > y));
        if (type(x) == T_REAL)
            return(make_boolean(sc, real(x) > y));
        if (type(x) == T_RATIO)
            return(make_boolean(sc, !ratio_leq_pi(x, y)));
        return(method_or_bust_with_type(sc, x, sc->gt_symbol, args, a_number_string, 1));
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x8(%rdx), %rdx
movq 0x8(%rdx), %rsi
movzbl (%rax), %edx
cmpl $0xd, %edx
je 0xa3ee0
cmpl $0xc, %edx
je 0xa3ed3
cmpl $0xb, %edx
jne 0xa3efd
xorl %ecx, %ecx
cmpq %rsi, 0x8(%rax)
setle %cl
movq 0x118(%rbx,%rcx,8), %rax
jmp 0xa3efb
movq %rax, %rdi
callq 0xa5ce5
movzbl %al, %eax
jmp 0xa3ef3
cvtsi2sd %rsi, %xmm0
movsd 0x8(%rax), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setbe %al
movq 0x118(%rbx,%rax,8), %rax
popq %rbx
retq
movq 0xf58(%rbx), %rdx
movq 0x80495(%rip), %r8      # 0x1243a0
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_car_t
static s7_pointer fx_car_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    val = slot_value(let_slots(sc->envir));
                    return((is_pair(val)) ? car(val) : g_car(sc, set_plist_1(sc, val)));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa3fc4
movq 0x8(%rax), %rax
retq
movq 0x700(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rdi), %rsi
jmp 0x5db91
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_cdr_t
static s7_pointer fx_cdr_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    val = slot_value(let_slots(sc->envir));
                    return((is_pair(val)) ? cdr(val) : g_cdr(sc, set_plist_1(sc, val)));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa3ff1
movq 0x10(%rax), %rax
retq
movq 0x700(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rdi), %rsi
jmp 0x5dbb2
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_cadr_t
static s7_pointer fx_cadr_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    val = slot_value(let_slots(sc->envir));
                    return(((is_pair(val)) && (is_pair(cdr(val)))) ? cadr(val) : g_cadr(sc, set_plist_1(sc, val)));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa4027
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xa4027
movq 0x8(%rcx), %rax
retq
movq 0x700(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rdi), %rsi
jmp 0x5dc81
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_eq_tu
static s7_pointer fx_is_eq_tu(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    check_next_let_slot(sc, __func__, arg, caddr(arg));
                    x = slot_value(let_slots(sc->envir));
                    y = slot_value(next_slot(let_slots(sc->envir)));
                    return(make_boolean(sc, (x == y) || ((is_unspecified(x)) && (is_unspecified(y)))));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
movq 0x10(%rax), %rcx
movl $0x118, %eax            # imm = 0x118
cmpq %rcx, %rdx
je 0xa414a
cmpb $0x5, (%rdx)
jne 0xa4145
cmpb $0x5, (%rcx)
je 0xa414a
movl $0x120, %eax            # imm = 0x120
movq (%rdi,%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_eq_ts
static s7_pointer fx_is_eq_ts(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    y = lookup(sc, opt2_sym(cdr(arg)));
                    return(make_boolean(sc, (x == y) || ((is_unspecified(x)) && (is_unspecified(y)))));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r14
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rsi
callq 0x7d158
movl $0x118, %ecx            # imm = 0x118
cmpq %rax, %r14
je 0xa4189
cmpb $0x5, (%r14)
jne 0xa4184
cmpb $0x5, (%rax)
je 0xa4189
movl $0x120, %ecx            # imm = 0x120
movq (%rbx,%rcx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_add_ti
static s7_pointer fx_add_ti(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) + integer(opt2_con(cdr(arg)))));
                    return(add_p_pp(sc, x, caddr(arg)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rsi
cmpb $0xb, (%rsi)
jne 0xa4246
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %r14
addq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa4261
leaq 0x71710(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0xa429a
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6bf00
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa4280
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_add_t1
static s7_pointer fx_add_t1(s7_scheme *sc, s7_pointer arg) /* sub_t1 was not useful */
                {
                    s7_pointer x;
                    x = slot_value(let_slots(sc->envir));
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) + 1));
                    return(g_add_x1_1(sc, x, cdr(arg)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xb, (%rax)
jne 0xa42d9
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa42ef
leaq 0x7167e(%rip), %rcx     # 0x115950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xa4328
movq 0x10(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x920da
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa430e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_subtract_t1
static s7_pointer fx_subtract_t1(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) - 1));
                    return(minus_c1(sc, x));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0xa4367
movq 0x8(%rsi), %rax
leaq -0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa4376
leaq 0x715f0(%rip), %rcx     # 0x115950
movq -0x8(%rcx,%rax,8), %rax
jmp 0xa43af
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92479
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa4395
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_subtract_ti
static s7_pointer fx_subtract_ti(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) - integer(opt2_con(cdr(arg)))));
                    return(subtract_p_pp(sc, x, caddr(arg)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xb, (%rax)
jne 0xa43f5
movq 0x8(%rax), %r14
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
subq 0x8(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa4413
leaq 0x71561(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0xa444c
movq 0x10(%rsi), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c331
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa4432
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_safe_closure_t_a
static s7_pointer fx_safe_closure_t_a(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer result;
                    check_let_slots(sc, __func__, code, opt2_sym(code));
                    gc_protect_direct(sc, sc->envir);
                    sc->envir = old_frame_with_slot(sc, closure_let(opt1_lambda(code)), slot_value(let_slots(sc->envir)));
                    result = fx_call(sc, closure_body(opt1_lambda(code)));
                    sc->envir = sc->stack_end[-2];
                    sc->stack_end -= 4;
                    return(result);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rdi), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rdi)
movq %rax, 0x10(%rcx)
movq 0x18(%rsi), %rax
movq 0x18(%rax), %r15
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
movq %r15, %rsi
callq 0x92a16
movq %r15, 0x8(%rbx)
movq 0x18(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, 0x8(%rbx)
addq $-0x20, %rcx
movq %rcx, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_tu
static s7_pointer fx_num_eq_tu(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    check_next_let_slot(sc, __func__, arg, caddr(arg));
                    x = slot_value(let_slots(sc->envir));
                    y = slot_value(next_slot(let_slots(sc->envir)));
                    if ((is_t_integer(x)) && (is_t_integer(y)))
                        return(make_boolean(sc, integer(x) == integer(y)));
                    return(num_eq_p_pp(sc, x, y));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
cmpb $0xb, (%rsi)
jne 0x6e8d2
cmpb $0xb, (%rdx)
jne 0x6e8d2
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_tg
static s7_pointer fx_num_eq_tg(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    y = slot_value(global_slot(opt2_sym(cdr(arg))));
                    if ((is_t_integer(x)) && (is_t_integer(y)))
                        return(make_boolean(sc, integer(x) == integer(y)));
                    return(num_eq_p_pp(sc, x, y));
                }

// Assembly:
movq %rsi, %rax
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rsi
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdx
cmpb $0xb, (%rsi)
jne 0x6e8d2
cmpb $0xb, (%rdx)
jne 0x6e8d2
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_ts
static s7_pointer fx_num_eq_ts(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    y = lookup(sc, opt2_sym(cdr(arg)));
                    if ((is_t_integer(x)) && (is_t_integer(y)))
                        return(make_boolean(sc, integer(x) == integer(y)));
                    return(num_eq_p_pp(sc, x, y));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r14
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rsi
callq 0x7d158
cmpb $0xb, (%r14)
jne 0xa4667
cmpb $0xb, (%rax)
jne 0xa4667
movq 0x8(%r14), %rcx
xorl %edx, %edx
cmpq 0x8(%rax), %rcx
setne %dl
movq 0x118(%rbx,%rdx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6e8d2
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_ti
static s7_pointer fx_num_eq_ti(s7_scheme *sc, s7_pointer arg)
                {
                    s7_int y;
                    s7_pointer val, args;
                    args = cdr(arg);
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    val = slot_value(let_slots(sc->envir));
                    y = integer(cadr(args));
                    if (is_t_integer(val))
                        return(make_boolean(sc, integer(val) == y));
                    return(fx_num_eq_xi_1(sc, args, val, y));
                }

// Assembly:
movq 0x10(%rsi), %rsi
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
cmpb $0xb, (%rdx)
jne 0x9292f
xorl %eax, %eax
cmpq %rcx, 0x8(%rdx)
setne %al
movq 0x118(%rdi,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_sqr_tt
static s7_pointer fx_sqr_tt(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(sc->envir));
                    if (is_float(x)) return(make_real(sc, real(x) * real(x)));
                    return(fx_sqr_1(sc, x));
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0xd, (%rsi)
jne 0xa4848
movsd 0x8(%rsi), %xmm0
mulsd %xmm0, %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa4827
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x91a68
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_t_car_u
static s7_pointer fx_c_t_car_u(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    check_next_let_slot(sc, __func__, arg, cadr(caddr(arg)));
                    val = slot_value(next_slot(let_slots(sc->envir)));
                    set_car(sc->t2_2, (is_pair(val)) ? car(val) : g_car(sc, set_plist_1(sc, val)));
                    set_car(sc->t2_1, slot_value(let_slots(sc->envir)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa48e1
movq 0x8(%rax), %rax
jmp 0xa48fb
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5db91
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_lint_let_ref_t
static s7_pointer fx_lint_let_ref_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer lt, sym, y;
                    check_let_slots(sc, __func__, arg, opt2_sym(arg));
                    lt = cdr(slot_value(let_slots(sc->envir)));
                    if (!is_let(lt))
                        return(wrong_type_argument_with_type(sc, sc->let_ref_symbol, 1, lt, a_let_string));
                    sym = opt2_sym(cdr(arg));
                    for (y = let_slots(lt); tis_slot(y); y = next_slot(y))
                        if (slot_symbol(y) == sym)
                            return(slot_value(y));
                    return(lint_let_ref_1(sc, outlet(lt), sym));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
cmpb $0x1c, (%rcx)
jne 0xa4969
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rdx
leaq 0x8(%rcx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0xa498e
cmpq %rdx, 0x8(%rax)
je 0xa4997
addq $0x18, %rax
jmp 0xa4955
movq 0x1230(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x70fdd(%rip), %rdx     # 0x115958
movq 0x140(%rdi), %r8
movq 0x74fcf(%rip), %r9      # 0x119958
jmp 0x9bbb
movq 0x10(%rcx), %rsi
jmp 0x92a46
movq 0x10(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_cdr_u
static s7_pointer fx_cdr_u(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_next_let_slot(sc, __func__, arg, cadr(arg));
                    val = slot_value(next_slot(let_slots(sc->envir)));
                    return((is_pair(val)) ? cdr(val) : g_cdr(sc, set_plist_1(sc, val)));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa4a12
movq 0x10(%rax), %rax
retq
movq 0x700(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rdi), %rsi
jmp 0x5dbb2
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_car_u
static s7_pointer fx_car_u(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_next_let_slot(sc, __func__, arg, cadr(arg));
                    val = slot_value(next_slot(let_slots(sc->envir)));
                    return((is_pair(val)) ? car(val) : g_car(sc, set_plist_1(sc, val)));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa4a43
movq 0x8(%rax), %rax
retq
movq 0x700(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rdi), %rsi
jmp 0x5db91
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_us
static s7_pointer fx_num_eq_us(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    check_next_let_slot(sc, __func__, arg, cadr(arg));
                    x = slot_value(next_slot(let_slots(sc->envir)));
                    y = lookup(sc, opt2_sym(cdr(arg)));
                    if ((is_t_integer(x)) && (is_t_integer(y)))
                        return(make_boolean(sc, integer(x) == integer(y)));
                    return(num_eq_p_pp(sc, x, y));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %r14
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rsi
callq 0x7d158
cmpb $0xb, (%r14)
jne 0xa4acb
cmpb $0xb, (%rax)
jne 0xa4acb
movq 0x8(%r14), %rcx
xorl %edx, %edx
cmpq 0x8(%rax), %rcx
setne %dl
movq 0x118(%rbx,%rdx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6e8d2
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_add_u_car_t
static s7_pointer fx_add_u_car_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val1, val2;
                    check_let_slots(sc, __func__, arg, opt2_sym(cdr(arg)));
                    check_next_let_slot(sc, __func__, arg, cadr(arg));
                    val2 = slot_value(let_slots(sc->envir));
                    val2 = (is_pair(val2)) ? car(val2) : g_car(sc, set_plist_1(sc, val2));
                    val1 = slot_value(next_slot(let_slots(sc->envir)));
                    if ((is_t_integer(val1)) && (is_t_integer(val2)))
                        return(make_integer(sc, integer(val1) + integer(val2)));
                    return(add_p_pp(sc, val1, val2));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xa4b39
movq 0x8(%rcx), %rdx
jmp 0xa4b5e
movq 0x700(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5db91
movq %rax, %rdx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0xa4b8e
cmpb $0xb, (%rdx)
jne 0xa4b8e
movq 0x8(%rdx), %r14
addq 0x8(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa4b9d
leaq 0x70dc8(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0xa4bd6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6bf00
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa4bbc
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_add_u1
static s7_pointer fx_add_u1(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_next_let_slot(sc, __func__, arg, cadr(arg));
                    x = slot_value(next_slot(let_slots(sc->envir)));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) + 1));
                    return(g_add_x1_1(sc, x, cdr(arg)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xb, (%rax)
jne 0xa4c6b
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa4c81
leaq 0x70cec(%rip), %rcx     # 0x115950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xa4cba
movq 0x10(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x920da
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa4ca0
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_subtract_u1
static s7_pointer fx_subtract_u1(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_next_let_slot(sc, __func__, arg, cadr(arg));
                    x = slot_value(next_slot(let_slots(sc->envir)));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) - 1));
                    return(minus_c1(sc, x));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0xa4cfd
movq 0x8(%rsi), %rax
leaq -0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa4d0c
leaq 0x70c5a(%rip), %rcx     # 0x115950
movq -0x8(%rcx,%rax,8), %rax
jmp 0xa4d45
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92479
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa4d2b
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opstq
static s7_pointer fx_c_opstq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cadr(arg);
                    set_car(sc->t2_1, lookup(sc, cadr(largs)));
                    check_let_slots(sc, __func__, arg, caddr(largs));
                    set_car(sc->t2_2, slot_value(let_slots(sc->envir)));
                    set_car(sc->t1_1, c_call(largs)(sc, sc->t2_1));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x570(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x578(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%r14), %rsi
movq %r14, %rdi
callq *0x20(%r15)
movq 0x568(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x568(%r14), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opstq_c
static s7_pointer fx_c_opstq_c(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cadr(arg);
                    check_let_slots(sc, __func__, arg, caddr(largs));
                    set_car(sc->t2_1, lookup(sc, cadr(largs)));
                    set_car(sc->t2_2, slot_value(let_slots(sc->envir)));
                    set_car(sc->t2_1, c_call(largs)(sc, sc->t2_1));
                    set_car(sc->t2_2, caddr(arg));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_pair_cdr_t
static s7_pointer fx_is_pair_cdr_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    check_let_slots(sc, __func__, arg, cadadr(arg));
                    p = slot_value(let_slots(sc->envir));
                    if (is_pair(p))
                        return(make_boolean(sc, is_pair(cdr(p))));
                    return(g_is_pair(sc, set_plist_1(sc, g_cdr(sc, set_plist_1(sc, p)))));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa50a2
movq 0x10(%rax), %rax
xorl %ecx, %ecx
cmpb $0x1, (%rax)
setne %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5dbb2
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x4b5a8
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_symbol_cadr_t
static s7_pointer fx_is_symbol_cadr_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    check_let_slots(sc, __func__, arg, cadadr(arg));
                    p = slot_value(let_slots(sc->envir));
                    if ((is_pair(p)) && (is_pair(cdr(p))))
                        return(make_boolean(sc, is_symbol(cadr(p))));
                    return(g_is_symbol(sc, set_plist_1(sc, g_cadr(sc, set_plist_1(sc, p)))));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa516f
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xa516f
movq 0x8(%rcx), %rax
xorl %ecx, %ecx
cmpb $0xa, (%rax)
setne %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5dc81
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x49dc5
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_null_cdr_t
static s7_pointer fx_is_null_cdr_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    check_let_slots(sc, __func__, arg, cadadr(arg));
                    p = slot_value(let_slots(sc->envir));
                    if (is_pair(p))
                        return(make_boolean(sc, is_null(cdr(p))));
                    return(g_is_null(sc, set_plist_1(sc, g_cdr(sc, set_plist_1(sc, p)))));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa5237
movq 0x10(%rax), %rax
xorl %ecx, %ecx
cmpq 0x110(%rbx), %rax
setne %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5dbb2
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x4c14f
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_null_cddr_t
static s7_pointer fx_is_null_cddr_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    check_let_slots(sc, __func__, arg, cadadr(arg));
                    p = slot_value(let_slots(sc->envir));
                    if ((is_pair(p)) && (is_pair(cdr(p))))
                        return(make_boolean(sc, is_null(cddr(p))));
                    return(g_is_null(sc, set_plist_1(sc, g_cddr(sc, set_plist_1(sc, p)))));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa52a4
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0xa52a4
movq 0x10(%rcx), %rax
xorl %ecx, %ecx
cmpq 0x110(%rbx), %rax
setne %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5dd1d
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x4c14f
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_type_car_t
static s7_pointer fx_is_type_car_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_let_slots(sc, __func__, arg, cadadr(arg));
                    val = slot_value(let_slots(sc->envir));
                    if (is_pair(val))
                        return(make_boolean(sc, (uint8_t)(opt3_byte(cdr(arg))) == type(car(val))));

                    if (has_active_methods(sc, val))
                    {
                        s7_pointer func;
                        func = find_method(sc, val, sc->car_symbol);
                        if (func != sc->undefined)
                            return(make_boolean(sc, type(s7_apply_function(sc, func, list_1(sc, val))) == (uint8_t)opt3_byte(cdr(arg))));
                    }
                    return(wrong_type_argument(sc, sc->car_symbol, 1, val, T_PAIR));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
cmpb $0x1, (%r15)
jne 0xa5379
movq 0x10(%r14), %rax
movb 0x28(%rax), %al
movq 0x8(%r15), %rcx
xorl %edx, %edx
cmpb (%rcx), %al
setne %dl
movq 0x118(%rbx,%rdx,8), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
testb $0x40, 0x3(%r15)
je 0xa540a
cmpb $0x1, 0x24c(%rbx)
jne 0xa540a
movq 0xd20(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0xa540a
movq %rax, %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xa53d1
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r15, 0x8(%rdx)
movq %r13, 0x10(%rdx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa34c
movb (%rax), %al
movq 0x10(%r14), %rcx
xorl %edx, %edx
cmpb 0x28(%rcx), %al
jmp 0xa5364
movq 0xd20(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x7053c(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0x7463e(%rip), %r9      # 0x119a68
movq %rbx, %rdi
movq %r15, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_car_t
static s7_pointer fx_c_car_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_let_slots(sc, __func__, arg, opt2_sym(cdr(arg)));
                    val = slot_value(let_slots(sc->envir));
                    set_car(sc->t1_1, (is_pair(val)) ? car(val) : g_car(sc, set_plist_1(sc, val)));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa552e
movq 0x8(%rax), %rax
jmp 0xa5548
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5db91
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_cdr_t
static s7_pointer fx_c_cdr_t(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_let_slots(sc, __func__, arg, opt2_sym(cdr(arg)));
                    val = slot_value(let_slots(sc->envir));
                    set_car(sc->t1_1, (is_pair(val)) ? cdr(val) : g_cdr(sc, set_plist_1(sc, val)));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa558b
movq 0x10(%rax), %rax
jmp 0xa55a5
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5dbb2
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_eq_car_t_q
static s7_pointer fx_is_eq_car_t_q(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer lst, a;
                    a = cdr(arg);
                    check_let_slots(sc, __func__, arg, opt3_sym(a));
                    lst = slot_value(let_slots(sc->envir));
                    if (is_pair(lst))
                        return(make_boolean(sc, car(lst) == opt2_con(a)));
                    return(make_boolean(sc, s7_is_eq(g_car(sc, set_plist_1(sc, lst)), opt2_con(a))));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa55fa
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq 0x20(%r14), %rax
setne %cl
leaq 0x118(,%rcx,8), %rcx
jmp 0xa563e
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5db91
movq 0x20(%r14), %rdx
cmpq %rdx, %rax
je 0xa5639
movl $0x120, %ecx            # imm = 0x120
cmpb $0x5, (%rax)
jne 0xa563e
xorl %eax, %eax
cmpb $0x5, (%rdx)
setne %al
leaq 0x118(,%rax,8), %rcx
jmp 0xa563e
movl $0x118, %ecx            # imm = 0x118
movq (%rbx,%rcx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_optq_s
static s7_pointer fx_c_optq_s(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cadr(arg);
                    check_let_slots(sc, __func__, arg, cadr(largs));
                    set_car(sc->t1_1, slot_value(let_slots(sc->envir)));
                    set_car(sc->t2_1, c_call(largs)(sc, sc->t1_1));
                    set_car(sc->t2_2, lookup(sc, caddr(arg)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x568(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x568(%rdi), %rsi
callq *0x20(%rax)
movq 0x570(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x7d158
movq 0x578(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x570(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_not_lt_ut
static s7_pointer fx_not_lt_ut(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    check_let_slots(sc, __func__, arg, caddr(cadr(arg)));
                    check_next_let_slot(sc, __func__, arg, cadadr(arg));
                    y = slot_value(next_slot(let_slots(sc->envir)));
                    x = slot_value(let_slots(sc->envir));
                    if ((is_t_integer(x)) && (is_t_integer(y)))
                        return(make_boolean(sc, integer(y) >= integer(x)));
                    return(make_boolean(sc, geq_b_7pp(sc, y, x)));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0xb, (%rdx)
jne 0xa579f
cmpb $0xb, (%rsi)
jne 0xa579f
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setl %cl
leaq 0x118(,%rcx,8), %rax
jmp 0xa57b4
movq %rbx, %rdi
callq 0x6f2ba
xorb $0x1, %al
movzbl %al, %eax
leaq 0x118(,%rax,8), %rax
movq (%rbx,%rax), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_not_oputq
static s7_pointer fx_not_oputq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cadr(arg);
                    check_let_slots(sc, __func__, arg, caddr(largs));
                    check_next_let_slot(sc, __func__, arg, cadr(largs));
                    set_car(sc->t2_1, slot_value(next_slot(let_slots(sc->envir))));
                    set_car(sc->t2_2, slot_value(let_slots(sc->envir)));
                    if (c_call(largs)(sc, sc->t2_1) == sc->F) return(sc->T);
                    return(sc->F);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x570(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x578(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x570(%rdi), %rsi
callq *0x20(%rax)
movq %rax, %rcx
movq 0x120(%rbx), %rax
cmpq %rax, %rcx
jne 0xa5818
movq 0x118(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_car_u
static s7_pointer fx_c_car_u(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer val;
                    check_next_let_slot(sc, __func__, arg, opt2_sym(cdr(arg)));
                    val = slot_value(next_slot(let_slots(sc->envir)));
                    set_car(sc->t1_1, (is_pair(val)) ? car(val) : g_car(sc, set_plist_1(sc, val)));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa58af
movq 0x8(%rax), %rax
jmp 0xa58c9
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5db91
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: tree_set_memq_direct
static s7_pointer tree_set_memq_direct(s7_scheme *sc, s7_pointer syms, s7_pointer tree)
    {
        s7_pointer p;
        if ((sc->safety > NO_SAFETY) &&
                (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))
            add_symbol_to_list(sc, car(p));
        return(make_boolean(sc, tree_set_memq(sc, tree)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x6a0(%rdi)
jle 0xa5963
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2cd63
testb %al, %al
je 0xa5963
movq 0x1940(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rdx
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0x3e07e(%rip), %rax     # 0xe39cd
movq %rax, 0x10(%rdx)
movq $0x1d, 0x8(%rdx)
movq %rbx, %rdi
callq 0x2cdc0
movq %rbx, %rdi
callq 0x7c981
cmpb $0x1, (%r15)
jne 0xa5995
movq 0x8(%r15), %rax
movl 0xa88(%rbx), %ecx
movl %ecx, 0x2c(%rax)
movl 0xa8c(%rbx), %ecx
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%r15), %r15
jmp 0xa596b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa234b
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_gt
static s7_pointer fx_c_gt(s7_scheme *sc, s7_pointer arg)
                {
                    check_let_slots(sc, __func__, arg, opt2_sym(cdr(arg)));
                    set_car(sc->t2_1, lookup_global(sc, cadr(arg)));
                    set_car(sc->t2_2, slot_value(let_slots(sc->envir)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
testb $0x1, 0x2(%r15)
jne 0xa5a3b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d158
testq %rax, %rax
jne 0xa5a43
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d1b2
jmp 0xa5a43
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opgsq_t_direct
static s7_pointer fx_c_opgsq_t_direct(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cdadr(arg);
                    return(((s7_p_pp_t)opt2_direct(cdr(arg)))(sc,
                                ((s7_p_pp_t)opt3_direct(cdr(arg)))(sc, lookup_global(sc, car(largs)), lookup(sc, opt2_sym(largs))),
                                slot_value(let_slots(sc->envir))));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rax), %rbp
movq 0x10(%rcx), %r13
movq 0x28(%rax), %r12
movq 0x8(%r13), %r15
testb $0x1, 0x2(%r15)
jne 0xa5bce
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d158
movq %rax, %r14
testq %rax, %rax
jne 0xa5bd6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d1b2
movq %rax, %r14
jmp 0xa5bd6
movq 0x10(%r15), %rax
movq 0x10(%rax), %r14
movq 0x20(%r13), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq *%r12
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: ratio_lt_pi
static bool ratio_lt_pi(s7_pointer x, s7_int y)
    {
        if ((y >= 0) && (numerator(x) < 0))
            return(true);
        if ((y <= 0) && (numerator(x) > 0))
            return(false);
        if (denominator(x) < s7_int32_max)
            return(numerator(x) < (y * denominator(x)));
        return(fraction(x) < y);
    }

// Assembly:
movq 0x8(%rdi), %rax
testq %rsi, %rsi
js 0xa5c92
testq %rax, %rax
js 0xa5c9a
testq %rsi, %rsi
sete %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
jne 0xa5c97
movq 0x10(%rdi), %rcx
xorl %edx, %edx
cmpb $0x0, 0x7e76b(%rip)     # 0x1243e4
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
cmoveq %rdx, %rdi
cmpq %rdi, %rcx
jge 0xa5c9d
imulq %rsi, %rcx
cmpq %rcx, %rax
setl %al
retq
testq %rax, %rax
jle 0xa5c6c
xorl %eax, %eax
retq
movb $0x1, %al
retq
movq %rax, -0x18(%rsp)
fildll -0x18(%rsp)
movq %rcx, -0x10(%rsp)
fildll -0x10(%rsp)
fdivrp %st, %st(1)
movq %rsi, -0x8(%rsp)
fildll -0x8(%rsp)
fucompi %st(1), %st
fstp %st(0)
seta %al
retq