LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x50(%rdi), %rdx
movq $0x1, 0x18(%rdx)
movq 0x50(%rdi), %rdx
leaq 0x20(%rdx), %rsi
movq %rsi, 0x50(%rdi)
movq %rcx, 0x10(%rdx)
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movq 0x18(%rcx), %rcx
movq 0x8(%rdi), %rsi
movq 0x18(%rsi), %r8
movq 0x20(%rdx), %rdi
cmpq %rdi, %r8
je 0xb88da
jle 0xb88d1
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %r8
cmpq %r8, %rdi
jl 0xb88c4
cmpq %rdi, %r8
jne 0xb895e
movq 0x18(%rdx), %rdi
movq 0x10(%rdi), %rdx
movq 0x250(%rbx), %rsi
incq %rsi
movq %rsi, 0x250(%rbx)
movq %rsi, 0x18(%rcx)
movq 0x8(%rcx), %rdi
movq %rdx, 0x10(%rdi)
movq 0x8(%rdi), %rdx
movq %rdi, 0x18(%rdx)
movq %rsi, 0x20(%rdx)
incl 0x28(%rdx)
movq %rcx, 0x8(%rbx)
movq 0x18(%rax), %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 %r14
jmpq *%rax
cmpb $0x1c, (%rsi)
jne 0xb8982
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xb897c
cmpq %rdx, 0x8(%rdi)
je 0xb88de
movq 0x18(%rdi), %rdi
jmp 0xb8967
movq 0x10(%rsi), %rsi
jmp 0xb895e
movq 0x10(%rdx), %rdi
cmpb $0x20, (%rdi)
je 0xb88de
xorl %edx, %edx
jmp 0xb88e2
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_safe_closure_s_a
static s7_pointer fx_safe_closure_s_a(s7_scheme *sc, s7_pointer code) /* also called from h_safe_closure_s_a in eval */
                {
                    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 = fx_call(sc, closure_body(opt1_lambda(code)));
                    sc->envir = sc->stack_end[-2];
                    sc->stack_end -= 4;
                    return(result);
                }

// Assembly:
pushq %rbx
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), %rcx
movq 0x18(%rax), %rax
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rcx), %rdi
cmpq %rdi, %r8
je 0xb89eb
jle 0xb89e6
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rdi
jl 0xb89d9
cmpq %rdi, %r8
jne 0xb8a4b
movq 0x18(%rcx), %rdi
movq 0x10(%rdi), %rcx
movq 0x250(%rbx), %rdx
incq %rdx
movq %rdx, 0x250(%rbx)
movq %rdx, 0x18(%rax)
movq 0x8(%rax), %rdi
movq %rcx, 0x10(%rdi)
movq 0x8(%rdi), %rcx
movq %rdi, 0x18(%rcx)
movq %rdx, 0x20(%rcx)
incl 0x28(%rcx)
movq %rax, 0x8(%rbx)
movq 0x18(%rsi), %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
retq
cmpb $0x1c, (%rdx)
jne 0xb8a6b
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
je 0xb8a65
cmpq %rcx, 0x8(%rdi)
je 0xb89ef
movq 0x18(%rdi), %rdi
jmp 0xb8a54
movq 0x10(%rdx), %rdx
jmp 0xb8a4b
movq 0x10(%rcx), %rdi
cmpb $0x20, (%rdi)
je 0xb89ef
xorl %ecx, %ecx
jmp 0xb89f3
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_c_closure_s_a
static s7_pointer fx_c_closure_s_a(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, fx_call(sc, 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x50(%rdi), %rdx
movq $0x1, 0x18(%rdx)
movq 0x50(%rdi), %rdx
leaq 0x20(%rdx), %rsi
movq %rsi, 0x50(%rdi)
movq %rcx, 0x10(%rdx)
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movq 0x18(%rcx), %rcx
movq 0x8(%rdi), %rsi
movq 0x18(%rsi), %r8
movq 0x20(%rdx), %rdi
cmpq %rdi, %r8
je 0xb8ae6
jle 0xb8add
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %r8
cmpq %r8, %rdi
jl 0xb8ad0
cmpq %rdi, %r8
jne 0xb8b66
movq 0x18(%rdx), %rdi
movq 0x10(%rdi), %rdx
movq 0x250(%rbx), %rsi
incq %rsi
movq %rsi, 0x250(%rbx)
movq %rsi, 0x18(%rcx)
movq 0x8(%rcx), %rdi
movq %rdx, 0x10(%rdi)
movq 0x8(%rdi), %rdx
movq %rdi, 0x18(%rdx)
movq %rsi, 0x20(%rdx)
incl 0x28(%rdx)
movq %rcx, 0x8(%rbx)
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%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 %r14
jmpq *%rax
cmpb $0x1c, (%rsi)
jne 0xb8b8a
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xb8b84
cmpq %rdx, 0x8(%rdi)
je 0xb8aea
movq 0x18(%rdi), %rdi
jmp 0xb8b6f
movq 0x10(%rsi), %rsi
jmp 0xb8b66
movq 0x10(%rdx), %rdi
cmpb $0x20, (%rdi)
je 0xb8aea
xorl %edx, %edx
jmp 0xb8aee
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb8d58
jle 0xb8d53
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb8d46
cmpq %rdx, %rsi
jne 0xb8d80
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x570(%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
cmpb $0x1c, (%rcx)
jne 0xb8da0
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb8d9a
cmpq %rax, 0x8(%rdx)
je 0xb8d5c
movq 0x18(%rdx), %rdx
jmp 0xb8d89
movq 0x10(%rcx), %rcx
jmp 0xb8d80
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb8d5c
xorl %eax, %eax
jmp 0xb8d60
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x8(%r15), %rsi
callq *0x20(%r15)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb8e34
jle 0xb8e2f
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb8e22
cmpq %rdx, %rsi
jne 0xb8e5c
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %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
cmpb $0x1c, (%rcx)
jne 0xb8e7c
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb8e76
cmpq %rax, 0x8(%rdx)
je 0xb8e38
movq 0x18(%rdx), %rdx
jmp 0xb8e65
movq 0x10(%rcx), %rcx
jmp 0xb8e5c
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb8e38
xorl %eax, %eax
jmp 0xb8e3c
// File: /workspace/github_c_makefile_star2_O3/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 0xb8f38
movq %rbx, %rdi
callq 0xb990b
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), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb8f8a
jle 0xb8f85
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb8f78
cmpq %rdx, %rsi
jne 0xb8fcb
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
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
cmpb $0x1c, (%rcx)
jne 0xb8feb
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb8fe5
cmpq %rax, 0x8(%rdx)
je 0xb8f8e
movq 0x18(%rdx), %rdx
jmp 0xb8fd4
movq 0x10(%rcx), %rcx
jmp 0xb8fcb
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb8f8e
xorl %eax, %eax
jmp 0xb8f92
// File: /workspace/github_c_makefile_star2_O3/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 0xb9019
movq %rbx, %rdi
callq 0xb990b
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_O3/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 %rbx
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), %rcx
movq 0x18(%rax), %rax
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rcx), %rdi
cmpq %rdi, %r8
je 0xb90fc
jle 0xb90f7
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rdi
jl 0xb90ea
cmpq %rdi, %r8
jne 0xb9161
movq 0x18(%rcx), %rdi
movq 0x10(%rdi), %rcx
movq 0x250(%rbx), %rdx
incq %rdx
movq %rdx, 0x250(%rbx)
movq %rdx, 0x18(%rax)
movq 0x8(%rax), %rdi
movq %rcx, 0x10(%rdi)
movq 0x8(%rdi), %rcx
movq %rdi, 0x18(%rcx)
movq %rdx, 0x20(%rcx)
incl 0x28(%rcx)
movq %rax, 0x8(%rbx)
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xb9181
movq 0x18(%rsi), %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 0xb9188
cmpb $0x1c, (%rdx)
jne 0xb919e
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
je 0xb917b
cmpq %rcx, 0x8(%rdi)
je 0xb9100
movq 0x18(%rdi), %rdi
jmp 0xb916a
movq 0x10(%rdx), %rdx
jmp 0xb9161
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
retq
movq 0x10(%rcx), %rdi
cmpb $0x20, (%rdi)
je 0xb9100
xorl %ecx, %ecx
jmp 0xb9104
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_and_2_closure_s
static s7_pointer fx_and_2_closure_s(s7_scheme *sc, s7_pointer code) /* safe_closure_s_a where "a" is fx_and_2 */
                {
                    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)));
                    result = fx_call(sc, code);  /* have to unwind the stack so this can't return */
                    if (result != sc->F)
                        result = fx_call(sc, cdr(code));
                    sc->envir = sc->stack_end[-2];
                    sc->stack_end -= 4;
                    return(result);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
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), %rcx
movq 0x18(%rax), %rax
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rcx), %rdi
cmpq %rdi, %r8
je 0xb920e
jle 0xb9205
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rdi
jl 0xb91f8
cmpq %rdi, %r8
jne 0xb9294
movq 0x18(%rcx), %rdi
movq 0x10(%rdi), %rcx
movq 0x250(%rbx), %rdx
incq %rdx
movq %rdx, 0x250(%rbx)
movq %rdx, 0x18(%rax)
movq 0x8(%rax), %rdi
movq %rcx, 0x10(%rdi)
movq 0x8(%rdi), %rcx
movq %rdi, 0x18(%rcx)
movq %rdx, 0x20(%rcx)
incl 0x28(%rcx)
movq %rax, 0x8(%rbx)
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb9278
movq 0x10(%r14), %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)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x1c, (%rdx)
jne 0xb92b8
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
je 0xb92b2
cmpq %rcx, 0x8(%rdi)
je 0xb9212
movq 0x18(%rdi), %rdi
jmp 0xb929d
movq 0x10(%rdx), %rdx
jmp 0xb9294
movq 0x10(%rcx), %rdi
cmpb $0x20, (%rdi)
je 0xb9212
xorl %ecx, %ecx
jmp 0xb9216
// File: /workspace/github_c_makefile_star2_O3/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 0xb92f2
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0xb9317
cmpq %rdx, 0x8(%rax)
je 0xb9320
movq 0x18(%rax), %rax
jmp 0xb92e1
movq 0x1230(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x8d654(%rip), %rdx     # 0x146958
movq 0x140(%rdi), %r8
movq 0x91646(%rip), %r9      # 0x14a958
jmp 0xa4e4
movq 0x10(%rcx), %rsi
jmp 0xba72d
movq 0x10(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x20(%rsi), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xb934e
jle 0xb9349
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xb933c
cmpq %rdx, %r8
jne 0xb937c
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x10(%rax), %rcx
cmpb $0x1c, (%rcx)
jne 0xb939c
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0xb93c1
cmpq %rdx, 0x8(%rax)
je 0xb93ca
movq 0x18(%rax), %rax
jmp 0xb936b
cmpb $0x1c, (%rcx)
jne 0xb93cf
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb9396
cmpq %rax, 0x8(%rdx)
je 0xb9352
movq 0x18(%rdx), %rdx
jmp 0xb9385
movq 0x10(%rcx), %rcx
jmp 0xb937c
movq 0x1230(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x8d5aa(%rip), %rdx     # 0x146958
movq 0x140(%rdi), %r8
movq 0x9159c(%rip), %r9      # 0x14a958
jmp 0xa4e4
movq 0x10(%rcx), %rsi
jmp 0xba72d
movq 0x10(%rax), %rax
retq
movq 0x10(%rax), %rdx
jmp 0xb9352
// File: /workspace/github_c_makefile_star2_O3/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 0xb9437
movq 0x10(%rax), %rcx
cmpq 0x110(%rdi), %rcx
je 0xb947a
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 0x5e3ec(%rip), %rcx     # 0x11780a
movq %rcx, 0x10(%rax)
movq $0x1c, 0x8(%rax)
movq 0x6e0(%rdi), %rcx
movq %rax, 0x8(%rcx)
jmp 0xb949e
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 0xb9480
leaq 0x5e388(%rip), %rax     # 0x1177f4
movq %rax, 0x10(%rcx)
movq $0x15, 0x8(%rcx)
jmp 0xb9493
movq 0x8(%rax), %rbx
jmp 0xb94bc
leaq 0x5e34d(%rip), %rax     # 0x1177d4
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 0x38dfa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb958a
cmpb $0x1, 0x24c(%rbx)
jne 0xb958a
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a63
movq %rax, %r12
movq 0xf58(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xb9530
movq %rbx, %rdi
callq 0xa550
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 0x9058e
cmpq 0x120(%rbx), %rax
setne %al
jmp 0xb95b7
movq 0xf58(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x8d3c4(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0x9151e(%rip), %r9      # 0x14aac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xa4e4
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_O3/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 0xb9686
cmpb $0x1, 0x24c(%rbx)
jne 0xb9686
movq %rdx, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a63
movq %rax, %r12
movq 0xf58(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xb962c
movq %rbx, %rdi
callq 0xa550
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 0x9058e
cmpq 0x120(%rbx), %rax
setne %al
jmp 0xb96b3
movq 0xf58(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x8d2c0(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %r8
movq 0x91422(%rip), %r9      # 0x14aac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xa4e4
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_O3/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 0xb9cff
leaq 0x4ea20(%rip), %rcx     # 0x108614
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 0xb9c32
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa550
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 0xb9cf1
addsd 0x8(%r14), %xmm0
jmp 0xb9cab
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 0xd387
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 0xb9cd6
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
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 0xb9d31
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
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 0xb9d75
movq %rbx, %rdi
callq 0xa550
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 0x9b5e4(%rip), %r8      # 0x1553a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %r9d
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/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 0xb9ec3
leaq 0x4e823(%rip), %rcx     # 0x108624
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
movq %rax, %r14
incq %r14
jno 0xb9f31
cvtsi2sd %rax, %xmm0
jmp 0xb9e27
movsd 0x8(%r14), %xmm0
addsd 0x4c201(%rip), %xmm0    # 0x106030
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb9e58
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xa550
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 0x4c1a3(%rip), %xmm0    # 0x106030
movsd 0x10(%r14), %xmm1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd387
movq 0x8caab(%rip), %rdx     # 0x146958
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb9f88
movq 0xba8(%rbx), %r15
movq 0x10(%rdx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb9eed
movq %rbx, %rdi
callq 0xa550
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 0x9b48e(%rip), %r8      # 0x1553a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe659
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xb9f4a
leaq 0x8ca0f(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xb9e73
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb9f69
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xb9e73
// File: /workspace/github_c_makefile_star2_O3/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 0xb9fd2
addq %rsi, %rcx
movq %rbx, %rdi
movq %rcx, %rsi
addq $0x30, %rsp
popq %rbx
jmp 0xcfa8
movq %rdx, %rax
imulq %r8, %rax
jo 0xb9ff2
movq %rsi, %r9
imulq %r8, %r9
jo 0xb9ff2
movq %rcx, %rdi
imulq %rdx, %rdi
jo 0xb9ff2
addq %rdi, %r9
jno 0xba070
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 0xba04f
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xa550
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 0xb9fc8
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_subtract_2f
static s7_pointer g_subtract_2f(s7_scheme *sc, s7_pointer args) /* (- x f) */
    {
        s7_pointer x;
        s7_double n;

        x = car(args);
        n = real(cadr(args));
        if (is_float(x)) return(make_real(sc, real(x) - n));

        switch (type(x))
        {
            case T_INTEGER: return(make_real(sc, integer(x) - n));
            case T_RATIO:   return(make_real(sc, fraction(x) - n));
            case T_REAL:    return(make_real(sc, real(x) - n));
            case T_COMPLEX: return(s7_make_complex(sc, real_part(x) - n, imag_part(x)));
            default:
                            return(method_or_bust_with_type(sc, x, sc->subtract_symbol, args, a_number_string, 1));
        }
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xba163
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movsd 0x8(%rcx), %xmm2
leaq 0x4e584(%rip), %rcx     # 0x108634
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq 0x8(%rsi), %xmm0
jmp 0xba0c6
movsd 0x8(%rsi), %xmm0
subsd %xmm2, %xmm0
jmp 0xba117
movsd 0x8(%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
subsd %xmm2, %xmm0
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0xd387
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x28(%rsp)
fildll 0x28(%rsp)
movq %rcx, 0x20(%rsp)
fildll 0x20(%rsp)
fdivrp %st, %st(1)
movsd %xmm2, 0x18(%rsp)
fsubl 0x18(%rsp)
fstpl 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xba142
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
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
retq
movq 0x1588(%rbx), %rdx
movq 0x9b22f(%rip), %r8      # 0x1553a0
movq %rbx, %rdi
movl $0x1, %r9d
addq $0x30, %rsp
popq %rbx
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_mul_xf
static s7_pointer g_mul_xf(s7_scheme *sc, s7_pointer x, s7_double y)
    {
        switch (type(x))
        {
            case T_INTEGER: return(make_real(sc, integer(x) * y));
            case T_RATIO:   return(make_real(sc, numerator(x) * y / denominator(x)));
            case T_REAL:    return(make_real(sc, real(x) * y));
            case T_COMPLEX: return(s7_make_complex(sc, real_part(x) * y, imag_part(x) * y));
            default:
                            return(method_or_bust_with_type(sc, x, sc->multiply_symbol, list_2(sc, make_real(sc, y), x), a_number_string, 1));
        }
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xba566
leaq 0x4e230(%rip), %rcx     # 0x108654
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%r14), %xmm0
mulsd %xmm1, %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xba465
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
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)
jmp 0xba558
mulsd 0x8(%r14), %xmm1
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xba4b6
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa550
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 0xba558
movsd 0x8(%r14), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x10(%r14), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd387
cvtsi2sdq 0x8(%r14), %xmm2
mulsd %xmm1, %xmm2
xorps %xmm0, %xmm0
cvtsi2sdq 0x10(%r14), %xmm0
divsd %xmm0, %xmm2
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xba53d
movq %rbx, %rdi
movsd %xmm2, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm2
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm2, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1358(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xba598
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm1
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0xd, (%r12)
movsd %xmm1, 0x8(%r12)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xba5dc
movq %rbx, %rdi
callq 0xa550
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 %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r12, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0x9ad7d(%rip), %r8      # 0x1553a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %r9d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_xi_1
static s7_pointer fx_num_eq_xi_1(s7_scheme *sc, s7_pointer args, s7_pointer val, s7_int y)
                {
#if S7_DEBUGGING
                    if (is_t_integer(val)) fprintf(stderr, "%s[%d]: %s is an integer\n", __func__, __LINE__, DISPLAY(val));
#endif
                    switch (type(val))
                    {
                        case T_RATIO:   return(sc->F);
                        case T_REAL:    return(make_boolean(sc, real(val) == y));
                        case T_COMPLEX: return(sc->F);
                        default: return(method_or_bust_with_type(sc, val, sc->num_eq_symbol, list_2(sc, val, cadr(args)), a_number_string, 1));
                    }
                    return(sc->T);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpl $0xe, %eax
je 0xba665
movq %rdx, %r14
cmpl $0xd, %eax
je 0xba66e
cmpl $0xc, %eax
jne 0xba694
movq 0x120(%rbx), %rax
jmp 0xba68a
cvtsi2sd %rcx, %xmm0
cmpneqsd 0x8(%r14), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movq 0x118(%rbx,%rax,8), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xea0(%rbx), %r15
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xba6c9
movq %rbx, %rdi
callq 0xa550
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 0x9ac90(%rip), %r8      # 0x1553a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: lint_let_ref_1
static s7_pointer lint_let_ref_1(s7_scheme *sc, s7_pointer lt, s7_pointer sym)
    {
        s7_pointer x, y;
        for (x = lt; is_let(x); x = outlet(x))
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == sym)
                    return(slot_value(y));

        if (has_methods(lt))
        {
            if (has_let_ref_fallback(lt))
                return(call_let_ref_fallback(sc, lt, sym));
        }
        else
        {
            y = global_slot(sym);
            if (is_slot(y))
                return(slot_value(y));
        }
        return(sc->undefined);
    }

// Assembly:
cmpb $0x1c, (%rsi)
jne 0xba753
movq %rsi, %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xba74a
cmpq %rdx, 0x8(%rcx)
je 0xba76a
movq 0x18(%rcx), %rcx
jmp 0xba739
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
je 0xba735
movq (%rsi), %rax
btl $0x1e, %eax
jb 0xba76f
movq 0x10(%rdx), %rax
cmpb $0x20, (%rax)
jne 0xba77d
movq 0x10(%rax), %rax
retq
movq 0x10(%rcx), %rax
retq
notl %eax
testl $0x44000000, %eax       # imm = 0x44000000
jne 0xba77d
jmp 0xb743
movq 0x128(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: i_ii_fc_combinable
static bool i_ii_fc_combinable(s7_scheme *sc, opt_info *opc, s7_i_ii_t func)
                {
                    if ((sc->pc > 1) &&
                            (opc == sc->opts[sc->pc - 2]))
                    {
                        opt_info *o1;
                        o1 = sc->opts[sc->pc - 1];
                        if ((o1->v[0].fi == opt_i_7pi_ss) || (o1->v[0].fi == ivref_7pi_ss))
                        {
                            opc->v[5].i = opc->v[2].i; /* move v2.i ("c" in fc = arg2) out of the symbols' way */
                            opc->v[4].i_7pi_f = o1->v[3].i_7pi_f;
                            opc->v[1].p = o1->v[1].p;
                            opc->v[2].p = o1->v[2].p;
                            if (func)
                            {
                                if (opc->v[3].i_ii_f == add_i_ii)
                                    opc->v[0].fi = opt_i_ii_fco_add;
                                else opc->v[0].fi = opt_i_ii_fco;
                            }
                            else opc->v[0].fi = opt_i_7ii_fco;
                            backup_pc(sc);
                            return(oo_set_type_2(opc, 6, 1, 2, OO_P, OO_I));
                        }
                    }
                    return(return_false(sc, NULL, __func__, __LINE__));
                }

// Assembly:
movl 0x2258(%rdi), %eax
cmpl $0x2, %eax
jl 0xbaa70
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xbaa70
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
movq (%rax), %rcx
leaq -0x18bba(%rip), %r8     # 0xa1e59
cmpq %r8, %rcx
setne %r8b
leaq 0x1fd(%rip), %r9        # 0xbac1e
cmpq %r9, %rcx
setne %cl
testb %cl, %r8b
jne 0xbaa70
movq 0x10(%rsi), %rcx
movq %rcx, 0x28(%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x20(%rsi)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
testq %rdx, %rdx
je 0xbaa73
leaq -0x33477(%rip), %rax    # 0x875e1
cmpq %rax, 0x18(%rsi)
leaq 0x1d8(%rip), %rcx       # 0xbac3b
leaq 0x1f6(%rip), %rax       # 0xbac60
cmoveq %rcx, %rax
jmp 0xbaa7a
xorl %eax, %eax
retq
leaq 0x21f(%rip), %rax       # 0xbac99
movq %rax, (%rsi)
decl 0x2258(%rdi)
movabsq $0x200000006, %rax      # imm = 0x200000006
movq %rax, 0x60(%rsi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x70(%rsi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_types_match
static s7_pointer opt_types_match(s7_scheme *sc, s7_pointer check, s7_pointer sym)
                {
                    s7_pointer slot, checker;
                    checker = s7_symbol_value(sc, check);
                    slot = symbol_to_slot(sc, sym);
                    if (is_slot(slot))
                    {
                        s7_pointer obj;
                        obj = slot_value(slot);
                        if (s7_apply_function(sc, checker, set_plist_1(sc, obj)) == sc->T)
                            return(slot);
                    }
                    return(NULL);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x9a93
movq 0x8(%rbx), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%r14), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0xbad11
jle 0xbad0c
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0xbacff
cmpq %rsi, %rdi
jne 0xbad51
movq (%r14,%rcx), %r15
cmpb $0x20, (%r15)
jne 0xbad45
movq 0x10(%r15), %rcx
movq 0x700(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x700(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaee6
cmpq 0x118(%rbx), %rax
je 0xbad48
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xbad11
movq 0x8(%rdx), %r15
testq %r15, %r15
je 0xbad70
cmpq %r14, 0x8(%r15)
je 0xbad15
movq 0x18(%r15), %r15
jmp 0xbad5f
movq 0x10(%rdx), %rdx
jmp 0xbad56
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_i_add_any_f
static s7_int opt_i_add_any_f(opt_info *o)
                {
                    s7_int sum = 0;
                    int32_t i;
                    oo_rc(o->sc, o, 2, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        sum += o1->v[0].fi(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
jle 0xbb0e6
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
addq %rax, %r14
incq %r15
cmpq %r15, 0x8(%rbx)
jg 0xbb0b9
jmp 0xbb0e9
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_i_multiply_any_f
static s7_int opt_i_multiply_any_f(opt_info *o)
                {
                    s7_int sum = 1;
                    int32_t i;
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        sum *= o1->v[0].fi(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
jle 0xbb137
movq %rdi, %r14
movl $0x1, %ebx
xorl %r15d, %r15d
movq 0x68(%r14), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
imulq %rax, %rbx
incq %r15
cmpq %r15, 0x8(%r14)
jg 0xbb109
jmp 0xbb13c
movl $0x1, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: d_dd_sf_combinable
static bool d_dd_sf_combinable(s7_scheme *sc, opt_info *opc, s7_d_dd_t func)
                {
                    if ((sc->pc > 1) &&
                            (opc == sc->opts[sc->pc - 2]))
                    {
                        opt_info *o1;
                        o1 = sc->opts[sc->pc - 1];
                        if (o1->v[0].fd == opt_d_7pi_ss)
                        {
                            if (func)
                            {
                                opc->v[4].d_dd_f = opc->v[3].d_dd_f; /* need room for 3 symbols */
                                opc->v[0].fd = opt_d_dd_sfo;
                            }
                            else
                            {
                                opc->v[4].d_7dd_f = opc->v[3].d_7dd_f; /* need room for 3 symbols */
                                opc->v[0].fd = opt_d_7dd_sfo;
                            }
                            opc->v[2].p = o1->v[1].p;
                            opc->v[3].p = o1->v[2].p;
                            opc->v[5].d_7pi_f = o1->v[3].d_7pi_f;
                            backup_pc(sc);
                            return(oo_set_type_3(opc, 6, 1, 2, 3, OO_D, OO_P, OO_I));
                        }
                    }
                    return(return_false(sc, NULL, __func__, __LINE__));
                }

// Assembly:
movl 0x2258(%rdi), %eax
cmpl $0x2, %eax
jl 0xbb4be
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xbb4be
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq -0x1af40(%rip), %rcx    # 0xa0579
cmpq %rcx, (%rax)
je 0xbb4c1
xorl %eax, %eax
retq
testq %rdx, %rdx
leaq 0xa25(%rip), %rcx       # 0xbbef0
leaq 0x9d1(%rip), %rdx       # 0xbbea3
cmoveq %rcx, %rdx
movq 0x18(%rsi), %rcx
movq %rcx, 0x20(%rsi)
movq %rdx, (%rsi)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rsi)
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsi)
decl 0x2258(%rdi)
movq $0x2, 0x70(%rsi)
movabsq $0x300000006, %rax      # imm = 0x300000006
movq %rax, 0x60(%rsi)
movl $0x1, 0x78(%rsi)
movb $0x1, %al
retq