LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_memq_car_s_2
static s7_pointer fx_memq_car_s_2(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, obj;
                    obj = lookup(sc, opt1_con(cdr(arg)));
                    if (is_pair(obj))
                        obj = car(obj);
                    else obj = g_car(sc, set_plist_1(sc, obj));
                    x = opt2_con(cdr(arg));
                    if (obj == car(x)) return(x);
                    if (obj == cadr(x)) return(cdr(x));
                    return(sc->F);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x18(%r15), %rsi
callq 0x7d158
cmpb $0x1, (%rax)
jne 0x90219
movq 0x8(%rax), %rax
jmp 0x90237
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5db91
movq 0x10(%r14), %r15
movq 0x20(%r15), %rcx
cmpq 0x8(%rcx), %rax
je 0x90252
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
je 0x90252
movq 0x120(%rbx), %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_memq_car_s
static s7_pointer fx_memq_car_s(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, obj;
                    obj = lookup(sc, opt1_con(cdr(arg)));
                    if (is_pair(obj))
                        obj = car(obj);
                    else obj = g_car(sc, set_plist_1(sc, obj));
                    x = opt2_con(cdr(arg));
                    while (true)
                    {
                        LOOP_4(if (obj == car(x)) return(x); x = cdr(x); if (!is_pair(x)) return(sc->F));
                    }
                    return(sc->F);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x18(%r15), %rsi
callq 0x7d158
cmpb $0x1, (%rax)
jne 0x9027e
movq 0x8(%rax), %rcx
jmp 0x9029f
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5db91
movq %rax, %rcx
movq 0x10(%r14), %r15
movq 0x20(%r15), %rax
cmpq 0x8(%rax), %rcx
je 0x902e6
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x902df
cmpq 0x8(%rax), %rcx
je 0x902e6
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x902df
cmpq 0x8(%rax), %rcx
je 0x902e6
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x902df
cmpq 0x8(%rax), %rcx
je 0x902e6
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x902a3
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_eq_car_q
static s7_pointer fx_is_eq_car_q(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer lst, a;
                    a = cdr(arg);
                    lst = lookup(sc, opt3_sym(a));
                    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 0x28(%r14), %rsi
callq 0x7d158
cmpb $0x1, (%rax)
jne 0x9031c
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq 0x20(%r14), %rax
setne %cl
leaq 0x118(,%rcx,8), %rcx
jmp 0x90360
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 0x9035b
movl $0x120, %ecx            # imm = 0x120
cmpb $0x5, (%rax)
jne 0x90360
xorl %eax, %eax
cmpb $0x5, (%rdx)
setne %al
leaq 0x118(,%rax,8), %rcx
jmp 0x90360
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_is_eq_caar_q
static s7_pointer fx_is_eq_caar_q(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer lst, a;
                    a = cdr(arg);
                    lst = lookup(sc, opt3_sym(a));
                    if ((is_pair(lst)) && (is_pair(car(lst))))
                        return(make_boolean(sc, caar(lst) == opt2_con(a)));
                    return(make_boolean(sc, s7_is_eq(g_caar(sc, set_plist_1(sc, lst)), opt2_con(a))));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x28(%r14), %rsi
callq 0x7d158
cmpb $0x1, (%rax)
jne 0x903a5
movq 0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x903a5
movq 0x8(%rcx), %rax
xorl %ecx, %ecx
cmpq 0x20(%r14), %rax
setne %cl
leaq 0x118(,%rcx,8), %rcx
jmp 0x903e9
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5dc33
movq 0x20(%r14), %rdx
cmpq %rdx, %rax
je 0x903e4
movl $0x120, %ecx            # imm = 0x120
cmpb $0x5, (%rax)
jne 0x903e9
xorl %eax, %eax
cmpb $0x5, (%rdx)
setne %al
leaq 0x118(,%rax,8), %rcx
jmp 0x903e9
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_opsq_c
static s7_pointer fx_c_opsq_c(s7_scheme *sc, s7_pointer arg)
                {
                    set_car(sc->t1_1, lookup(sc, opt1_con(cdr(arg))));
                    set_car(sc->t2_1, c_call(cadr(arg))(sc, sc->t1_1));
                    set_car(sc->t2_2, opt2_con(cdr(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 0x18(%rax), %rsi
callq 0x7d158
movq 0x568(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x568(%r14), %rsi
movq %r14, %rdi
callq *0x20(%rax)
movq 0x570(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x20(%rax), %rax
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_is_eq_sq
static s7_pointer fx_not_is_eq_sq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    x = lookup(sc, opt2_sym(cdr(arg)));
                    y = opt3_any(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 0x10(%rsi), %r14
movq 0x20(%r14), %rsi
callq 0x7d158
movq 0x28(%r14), %rdx
cmpq %rdx, %rax
je 0x906e6
movl $0x118, %ecx            # imm = 0x118
cmpb $0x5, (%rax)
jne 0x906eb
cmpb $0x5, (%rdx)
jne 0x906eb
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_c_opscq
static s7_pointer fx_c_opscq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cadr(arg);
                    set_car(sc->t2_1, lookup(sc, cadr(largs)));
                    set_car(sc->t2_2, opt2_con(cdr(largs)));
                    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 0x10(%r15), %rax
movq 0x20(%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_not_is_eq_ss
static s7_pointer fx_not_is_eq_ss(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    x = lookup(sc, opt2_sym(cdr(arg)));
                    y = lookup(sc, opt3_sym(cdr(arg)));
                    return(make_boolean(sc, (x != y) && ((!is_unspecified(x)) || (!is_unspecified(y)))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x20(%r15), %rsi
callq 0x7d158
movq %rax, %r14
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x7d158
cmpq %rax, %r14
je 0x9079c
movl $0x118, %ecx            # imm = 0x118
cmpb $0x5, (%r14)
jne 0x907a1
cmpb $0x5, (%rax)
jne 0x907a1
movl $0x120, %ecx            # imm = 0x120
movq (%rbx,%rcx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_not_opssq
static s7_pointer fx_not_opssq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cadr(arg);
                    set_car(sc->t2_1, lookup(sc, cadr(largs)));
                    set_car(sc->t2_2, lookup(sc, opt2_sym(cdr(largs))));
                    if (c_call(largs)(sc, sc->t2_1) == sc->F) return(sc->T);
                    return(sc->F);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq %rax, %rcx
movq 0x120(%rbx), %rax
cmpq %rax, %rcx
jne 0x90811
movq 0x118(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opssq
static s7_pointer fx_c_opssq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cadr(arg);
                    set_car(sc->t2_1, lookup(sc, cadr(largs)));
                    set_car(sc->t2_2, lookup(sc, opt2_sym(cdr(largs)))); /* caddr(largs) */
                    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, %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 0x10(%r15), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%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: direct_c_c_opssq
static s7_pointer direct_c_c_opssq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    s7_double x2;
                    arg = cdr(arg);
                    largs = cdadr(arg);
                    x2 = ((s7_d_pd_t)opt3_direct(cdr(arg)))(lookup(sc, car(largs)),
                            real_to_double(sc, lookup(sc, opt2_sym(largs)), "number_to_double"));
                    return(((s7_p_dd_t)opt2_direct(arg))(sc, real_to_double(sc, car(arg), "*"), x2));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rax), %r12
movq 0x10(%rcx), %r13
movq 0x8(%r13), %rsi
callq 0x7d158
movq %rax, %r14
movq 0x20(%r13), %rsi
movq %rbx, %rdi
callq 0x7d158
cmpb $0xd, (%rax)
jne 0x90938
movsd 0x8(%rax), %xmm0
jmp 0x9094a
leaq 0x52e24(%rip), %rdx     # 0xe3763
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc263
movq %r14, %rdi
callq *%r12
movaps %xmm0, %xmm1
movq 0x8(%r15), %rsi
movq 0x20(%r15), %rax
cmpb $0xd, (%rsi)
jne 0x90967
movsd 0x8(%rsi), %xmm0
jmp 0x90988
leaq 0x529c2(%rip), %rdx     # 0xe3330
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
movq %rax, %r14
callq 0xc263
movq %r14, %rax
movsd 0x8(%rsp), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: direct_c_opsq_opsq
static s7_pointer direct_c_opsq_opsq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_double x1, x2;
                    s7_pointer p;
                    p = cdr(arg);
                    x1 = ((s7_d_p_t)opt3_direct(p))(lookup(sc, cadar(p)));
                    x2 = ((s7_d_p_t)opt3_direct(cdr(p)))(lookup(sc, cadadr(p)));
                    return(((s7_p_dd_t)opt2_direct(p))(sc, x1, x2));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r14), %rax
movq 0x28(%r14), %r15
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq %rax, %rdi
callq *%r15
movsd %xmm0, 0x8(%rsp)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rax), %r15
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rax, %rdi
callq *%r15
movaps %xmm0, %xmm1
movq 0x20(%r14), %rax
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opsq_opsq
static s7_pointer fx_c_opsq_opsq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    largs = cdr(arg);
                    set_car(sc->t1_1, lookup(sc, cadar(largs)));
                    gc_protect_direct(sc, c_call(car(largs))(sc, sc->t1_1));
                    largs = cadr(largs);
                    set_car(sc->t1_1, lookup(sc, cadr(largs)));
                    set_car(sc->t2_2, c_call(largs)(sc, sc->t1_1));
                    set_car(sc->t2_1, sc->stack_end[-2]);
                    sc->stack_end -= 4;
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
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_not_is_eq_car_q
static s7_pointer fx_not_is_eq_car_q(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer lst, a;
                    a = opt2_pair(cdr(arg));
                    lst = lookup(sc, opt2_sym(a));
                    if (is_pair(lst))
                        return(make_boolean(sc, car(lst) != opt3_any(a)));
                    return(make_boolean(sc, !s7_is_eq(g_car(sc, set_plist_1(sc, lst)), opt3_any(a))));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x20(%rax), %r14
movq 0x20(%r14), %rsi
callq 0x7d158
cmpb $0x1, (%rax)
jne 0x90b88
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq 0x28(%r14), %rax
sete %cl
leaq 0x118(,%rcx,8), %rcx
jmp 0x90bcc
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
callq 0x5db91
movq 0x28(%r14), %rdx
cmpq %rdx, %rax
je 0x90bc7
movl $0x118, %ecx            # imm = 0x118
cmpb $0x5, (%rax)
jne 0x90bcc
xorl %eax, %eax
cmpb $0x5, (%rdx)
sete %al
leaq 0x118(,%rax,8), %rcx
jmp 0x90bcc
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_c_op_opsq_q
static s7_pointer fx_c_op_opsq_q(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer arg;
                    arg = cadadr(code);
                    set_car(sc->t1_1, lookup(sc, cadr(arg)));
                    set_car(sc->t1_1, c_call(arg)(sc, sc->t1_1));
                    set_car(sc->t1_1, c_call(cadr(code))(sc, sc->t1_1));
                    return(c_call(code)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%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_s_op_s_opssqq_direct
static s7_pointer fx_c_s_op_s_opssqq_direct(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer args, val1;
                    args = caddr(code);
                    val1 = caddr(args);
                    return(((s7_p_pp_t)opt3_direct(code))(sc,
                                lookup(sc, cadr(code)),
                                ((s7_p_pp_t)opt2_direct(cdr(code)))(sc,
                                lookup(sc, cadr(args)),
                                ((s7_p_pp_t)opt3_direct(cdr(code)))(sc, lookup(sc, cadr(val1)), lookup(sc, caddr(val1))))));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %r12
movq 0x28(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rbp
callq 0x7d158
movq %rax, 0x8(%rsp)
movq 0x20(%r12), %r13
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rax, %r15
movq 0x28(%r12), %r14
movq 0x10(%rbp), %rbp
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rax, %r12
movq 0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq *%r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq *%r13
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x10(%rsp), %rax
addq $0x18, %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: fx_c_s_op_s_opssqq
static s7_pointer fx_c_s_op_s_opssqq(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer args, val, val1;
                    args = caddr(code);
                    val1 = caddr(args);
                    val = lookup(sc, cadr(args));
                    set_car(sc->t2_1, lookup(sc, cadr(val1)));
                    set_car(sc->t2_2, lookup(sc, opt2_sym(cdr(val1))));
                    set_car(sc->t2_2, c_call(val1)(sc, sc->t2_1));
                    set_car(sc->t2_1, val);
                    set_car(sc->t2_2, c_call(args)(sc, sc->t2_1));
                    set_car(sc->t2_1, lookup(sc, cadr(code)));
                    return(c_call(code)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r12
movq 0x10(%r12), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rax
movq 0x8(%rax), %r13
callq 0x7d158
movq %rax, %r15
movq 0x10(%r13), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r13), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_op_opssq_q_s_direct
static s7_pointer fx_c_op_opssq_q_s_direct(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer arg;
                    arg = opt1_pair(cdr(code));
                    return(((s7_p_pp_t)opt3_direct(code))(sc,
                                ((s7_p_p_t)opt2_direct(cdr(code)))(sc,
                                ((s7_p_pp_t)opt3_direct(cdr(code)))(sc, lookup(sc, cadr(arg)), lookup(sc, caddr(arg)))),
                                lookup(sc, caddr(code))));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x28(%rsi), %rcx
movq %rcx, (%rsp)
movq 0x18(%rax), %rcx
movq 0x20(%rax), %r12
movq 0x28(%rax), %r13
movq 0x10(%rcx), %rbp
movq 0x8(%rbp), %rsi
callq 0x7d158
movq %rax, %r15
movq 0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq *%r13
movq %rbx, %rdi
movq %rax, %rsi
callq *%r12
movq %rax, %r15
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq (%rsp), %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: fx_safe_closure_s_d
static s7_pointer fx_safe_closure_s_d(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer result;
                    gc_protect_direct(sc, sc->envir);
                    sc->envir = old_frame_with_slot(sc, closure_let(opt1_lambda(code)), lookup(sc, opt2_sym(code)));
                    result = d_call(sc, car(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 0x20(%rsi), %rsi
movq 0x18(%rax), %r15
callq 0x7d158
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x92a16
movq %r15, 0x8(%rbx)
movq 0x18(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%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_c_closure_s_d
static s7_pointer fx_c_closure_s_d(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer clo_arg;
                    clo_arg = cadr(arg);
                    gc_protect_direct(sc, sc->envir);
                    sc->envir = old_frame_with_slot(sc, closure_let(opt1_lambda(clo_arg)), lookup(sc, opt2_sym(clo_arg)));
                    set_car(sc->t1_1, d_call(sc, car(closure_body(opt1_lambda(clo_arg)))));
                    sc->envir = sc->stack_end[-2];
                    sc->stack_end -= 4;
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r12
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(%r12), %rax
movq 0x20(%r12), %rsi
movq 0x18(%rax), %r15
callq 0x7d158
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x92a16
movq %r15, 0x8(%rbx)
movq 0x18(%r12), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rcx
movq %rcx, 0x8(%rbx)
addq $-0x20, %rax
movq %rax, 0x50(%rbx)
movq 0x20(%r14), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_sa
static s7_pointer fx_c_sa(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer a1;
                    a1 = cdr(arg);
                    set_car(sc->t2_2, fx_call(sc, cdr(a1)));
                    set_car(sc->t2_1, lookup(sc, car(a1)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x578(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x7d158
movq 0x570(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x570(%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_as
static s7_pointer fx_c_as(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer a1;
                    a1 = cdr(arg);
                    set_car(sc->t2_1, fx_call(sc, a1));
                    set_car(sc->t2_2, lookup(sc, cadr(a1)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
movq 0x8(%r15), %rsi
callq *0x20(%r15)
movq 0x570(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %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
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_aa
static s7_pointer fx_c_aa(s7_scheme *sc, s7_pointer arg)
                {
                    check_stack_size(sc); /* needed in t101-aux-18.scm */
                    gc_protect_direct(sc, fx_call(sc, cdr(arg)));
                    set_car(sc->t2_2, fx_call(sc, cddr(arg)));
                    set_car(sc->t2_1, T_Pos(sc->stack_end[-2]));
                    sc->stack_end -= 4;
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq 0x58(%rdi), %rax
jb 0x913b2
movq %rbx, %rdi
callq 0x91caf
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
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_c_opsaq
static s7_pointer fx_c_opsaq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    check_stack_size(sc); /* t101 + s7test full */
                    p = cadr(arg);
                    set_car(sc->t2_2, fx_call(sc, cddr(p)));
                    set_car(sc->t2_1, lookup(sc, cadr(p)));
                    set_car(sc->t1_1, c_call(p)(sc, sc->t2_1));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq 0x58(%rdi), %rax
jb 0x91445
movq %rbx, %rdi
callq 0x91caf
movq 0x10(%r14), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%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_opaaq
static s7_pointer fx_c_opaaq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    check_stack_size(sc); /* t101 + s7test full */
                    p = cadr(arg);
                    sc->stack_end[3] = (s7_pointer)OP_GC_PROTECT;
                    sc->stack_end += 4;
                    sc->stack_end[-2] = fx_call(sc, cdr(p));
                    set_car(sc->t2_2, fx_call(sc, cddr(p)));
                    set_car(sc->t2_1, sc->stack_end[-2]);
                    sc->stack_end -= 4;

                    set_car(sc->t1_1, c_call(p)(sc, sc->t2_1));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq 0x58(%rdi), %rax
jb 0x914d4
movq %rbx, %rdi
callq 0x91caf
movq 0x50(%rbx), %rax
movq 0x10(%r14), %rcx
movq 0x8(%rcx), %r15
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rbx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, -0x10(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%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_and_pair_closure_s
static s7_pointer fx_and_pair_closure_s(s7_scheme *sc, s7_pointer code) /* safe_closure_s_a where "a" is fx_and_2 with is_pair as first clause */
                {
                    s7_pointer result;
                    gc_protect_direct(sc, sc->envir);
                    sc->envir = old_frame_with_slot(sc, closure_let(opt1_lambda(code)), lookup(sc, opt2_sym(code)));
                    code = cdar(closure_body(opt1_lambda(code)));
                    if (is_pair(slot_value(let_slots(sc->envir)))) /* pair? arg = func par, pair? is global, symbol_id=0 */
                        result = fx_call(sc, cdr(code));
                    else result = sc->F;
                    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 0x20(%rsi), %rsi
movq 0x18(%rax), %r15
callq 0x7d158
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x92a16
movq %r15, 0x8(%rbx)
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x915dd
movq 0x18(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0x915e4
movq 0x120(%rbx), %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: g_lint_let_ref
static inline s7_pointer g_lint_let_ref(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer lt, y, sym;
        lt = car(args);
        if (!is_let(lt))
            return(wrong_type_argument_with_type(sc, sc->let_ref_symbol, 1, lt, a_let_string));
        sym = cadr(args);
        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(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0x916c1
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rdx
leaq 0x8(%rcx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x916e6
cmpq %rdx, 0x8(%rax)
je 0x916ef
addq $0x18, %rax
jmp 0x916ad
movq 0x1230(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x84285(%rip), %rdx     # 0x115958
movq 0x140(%rdi), %r8
movq 0x88277(%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_lint_let_ref
static s7_pointer fx_lint_let_ref(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer lt, sym, y;
                    lt = cdr(lookup(sc, opt2_sym(arg)));  /* (var-ref local-var) -> local-var, opt_sym2(arg) == cadr(arg) */
                    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));             /* (let-ref (cdr v) 'ref) -> ref == opt3_sym(cdar(closure_body(opt1_lambda(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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
callq 0x7d158
movq 0x10(%rax), %rcx
cmpb $0x1c, (%rcx)
jne 0x91730
movq 0x10(%r14), %rax
movq 0x20(%rax), %rdx
leaq 0x8(%rcx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x9175f
cmpq %rdx, 0x8(%rax)
je 0x91772
addq $0x18, %rax
jmp 0x9171c
movq 0x1230(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x84216(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0x88208(%rip), %r9      # 0x119958
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9bbb
movq 0x10(%rcx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92a46
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: check_quote
static inline s7_pointer check_quote(s7_scheme *sc, s7_pointer code)
                {
                    if (!is_pair(cdr(code)))                    /* (quote . -1) */
                    {
                        if (is_null(cdr(code)))
                            eval_error(sc, "quote: not enough arguments: ~A", 31, code);
                        eval_error(sc, "quote: stray dot?: ~A", 21, code);
                    }
                    if (is_not_null(cddr(code)))             /* (quote . (1 2)) or (quote 1 1) */
                        eval_error(sc, "quote: too many arguments ~A", 28, code);
                    return(cadr(code));

                    /* I think a quoted list in another list can be applied to a function, come here and
                     *   be changed to unchecked, set-cdr! or something clobbers the argument so we get
                     *   here on the next time around with the equivalent of (quote . 0) if unchecked
                     * so set-cdr! of constant -- if marked immutable, we could catch this case and clear.
                     */
                }

// Assembly:
pushq %rbx
movq 0x10(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x917dd
movq 0x10(%rax), %rcx
cmpq 0x110(%rdi), %rcx
je 0x91820
movq 0x1918(%rdi), %rbx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x51fe6(%rip), %rcx     # 0xe37aa
movq %rcx, 0x10(%rax)
movq $0x1c, 0x8(%rax)
movq 0x6e0(%rdi), %rcx
movq %rax, 0x8(%rcx)
jmp 0x91844
movslq 0x7dc(%rdi), %rcx
leal 0x1(%rcx), %edx
andl $0x7, %edx
movq 0x820(%rdi), %r8
movq (%r8,%rcx,8), %rcx
movq 0x1918(%rdi), %rbx
cmpq 0x110(%rdi), %rax
movl %edx, 0x7dc(%rdi)
je 0x91826
leaq 0x51f82(%rip), %rax     # 0xe3794
movq %rax, 0x10(%rcx)
movq $0x15, 0x8(%rcx)
jmp 0x91839
movq 0x8(%rax), %rbx
jmp 0x91862
leaq 0x51f47(%rip), %rax     # 0xe3774
movq %rax, 0x10(%rcx)
movq $0x1f, 0x8(%rcx)
movq 0x6e0(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x6e0(%rdi), %rdx
movq %rbx, %rsi
callq 0x2cdc0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: gt_out_y
static bool gt_out_y(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, y))
            return(find_and_apply_method(sc, find_let(sc, y), sc->gt_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->gt_symbol, 2, y, T_REAL);
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testb $0x40, 0x3(%rdx)
je 0x91930
cmpb $0x1, 0x24c(%rbx)
jne 0x91930
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq %rax, %r12
movq 0xf58(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x918d6
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x73dc9
cmpq 0x120(%rbx), %rax
setne %al
jmp 0x9195d
movq 0xf58(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x8401e(%rip), %rdx     # 0x115960
movq 0x140(%rbx), %r8
movq 0x88178(%rip), %r9      # 0x119ac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x9bbb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: gt_out_x
static bool gt_out_x(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, x))
            return(find_and_apply_method(sc, find_let(sc, x), sc->gt_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->gt_symbol, 1, x, T_REAL);
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testb $0x40, 0x3(%rsi)
je 0x91a2c
cmpb $0x1, 0x24c(%rbx)
jne 0x91a2c
movq %rdx, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq %rax, %r12
movq 0xf58(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x919d2
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x73dc9
cmpq 0x120(%rbx), %rax
setne %al
jmp 0x91a59
movq 0xf58(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x83f1a(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0x8807c(%rip), %r9      # 0x119ac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x9bbb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_add_xf
static s7_pointer g_add_xf(s7_scheme *sc, s7_pointer x, s7_double y)
    {
        if (is_t_real(x)) return(make_real(sc, real(x) + y));
        switch (type(x))
        {
            case T_INTEGER: return(make_real(sc, integer(x) + y));
            case T_RATIO:   return(make_real(sc, fraction(x) + y));
            case T_COMPLEX: return(s7_make_complex(sc, real_part(x) + y, imag_part(x)));
            default:
                            return(method_or_bust_with_type(sc, x, sc->add_symbol, list_2(sc, x, make_real(sc, y)), a_number_string, 1));
        }
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x91ffe
leaq 0x42715(%rip), %rcx     # 0xd4608
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq 0x8(%r14), %xmm1
addsd %xmm0, %xmm1
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x91f31
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm1
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm1, 0x8(%rax)
jmp 0x91ff0
addsd 0x8(%r14), %xmm0
jmp 0x91faa
addsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc152
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movq %rax, 0x28(%rsp)
fildll 0x28(%rsp)
movq %rcx, 0x20(%rsp)
fildll 0x20(%rsp)
fdivrp %st, %st(1)
movsd %xmm0, 0x18(%rsp)
faddl 0x18(%rsp)
fstpl 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x91fd5
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 $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xba8(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92030
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), %r12
movq $0xd, (%r12)
movsd %xmm0, 0x8(%r12)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x92074
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0x922e5(%rip), %r8      # 0x1243a0
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_add_x1_1
static s7_pointer g_add_x1_1(s7_scheme *sc, s7_pointer x, s7_pointer args)
    {
        switch (type(x))
        {
#if HAVE_OVERFLOW_CHECKS
            case T_INTEGER:
                {
                    s7_int val;
                    if (add_overflow(integer(x), 1, &val))
                        return(make_real(sc, (double)integer(x) + 1.0));
                    return(make_integer(sc, val));
                }
#else
            case T_INTEGER: return(make_integer(sc, integer(x) + 1));
#endif
            case T_RATIO:   return(add_ratios(sc, x, small_int(1)));
            case T_REAL:    return(make_real(sc, real(x) + 1.0));
            case T_COMPLEX: return(s7_make_complex(sc, real_part(x) + 1.0, imag_part(x)));
            default:
                            return(method_or_bust_with_type(sc, x, sc->add_symbol, cons(sc, x, cdr(args)), a_number_string, 1));
        }
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x921c0
leaq 0x4251a(%rip), %rcx     # 0xd4618
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
movq %rax, %r14
incq %r14
jno 0x9222c
cvtsi2sd %rax, %xmm0
jmp 0x92124
movsd 0x8(%r14), %xmm0
addsd 0x3ff04(%rip), %xmm0    # 0xd2030
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92155
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x9c27
movsd (%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 $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd 0x8(%r14), %xmm0
addsd 0x3fea6(%rip), %xmm0    # 0xd2030
movsd 0x10(%r14), %xmm1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc152
movq 0x837ae(%rip), %rdx     # 0x115958
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x92283
movq 0xba8(%rbx), %r15
movq 0x10(%rdx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x921ea
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0x92191(%rip), %r8      # 0x1243a0
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcf9a
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x92245
leaq 0x83714(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x92170
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92264
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)
jmp 0x92170
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: add_ratios_1
static s7_pointer add_ratios_1(s7_scheme *sc, s7_int n1, s7_int d1, s7_int n2, s7_int d2)
    {
        if (d1 == d2)                                     /* the easy case -- if overflow here, it matches the int case */
            return(s7_make_ratio(sc, n1 + n2, d1));

#if HAVE_OVERFLOW_CHECKS
        {
            s7_int n1d2, n2d1, d1d2, dn;
            if ((multiply_overflow(d1, d2, &d1d2)) ||
                    (multiply_overflow(n1, d2, &n1d2)) ||
                    (multiply_overflow(n2, d1, &n2d1)) ||
                    (add_overflow(n1d2, n2d1, &dn)))
                return(make_real(sc, ((long_double)n1 / (long_double)d1) + ((long_double)n2 / (long_double)d2)));
            return(s7_make_ratio(sc, dn, d1d2));
        }
#else
        return(s7_make_ratio(sc, n1 * d2 + n2 * d1, d1 * d2));
#endif
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq %r8, %rdx
jne 0x922c9
addq %rsi, %rcx
movq %rbx, %rdi
movq %rcx, %rsi
addq $0x30, %rsp
popq %rbx
jmp 0xbd87
movq %rdx, %rax
imulq %r8, %rax
jo 0x922e9
movq %rsi, %r9
imulq %r8, %r9
jo 0x922e9
movq %rcx, %rdi
imulq %rdx, %rdi
jo 0x922e9
addq %rdi, %r9
jno 0x92367
movq %rsi, 0x10(%rsp)
fildll 0x10(%rsp)
movq %rdx, 0x18(%rsp)
fildll 0x18(%rsp)
fdivrp %st, %st(1)
movq %rcx, 0x20(%rsp)
fildll 0x20(%rsp)
movq %r8, 0x28(%rsp)
fildll 0x28(%rsp)
fdivrp %st, %st(1)
faddp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92346
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x9c27
movsd (%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 $0x30, %rsp
popq %rbx
retq
movq %rbx, %rdi
movq %r9, %rsi
movq %rax, %rdx
jmp 0x922bf