LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xc04f6
jle 0xc04ed
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %r8
cmpq %r8, %rdi
jl 0xc04e0
cmpq %rdi, %r8
jne 0xc057a
movq 0x18(%rdx), %rdx
movq 0x10(%rdx), %rdi
movq 0x250(%rbx), %rdx
incq %rdx
movq %rdx, 0x250(%rbx)
movq %rdx, 0x18(%rcx)
movq 0x8(%rcx), %rsi
movq %rdi, 0x10(%rsi)
movq 0x8(%rsi), %rdi
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
incl 0x28(%rdi)
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 0xc05ae
movq 0x8(%rsi), %r9
testq %r9, %r9
sete %r8b
je 0xc059c
cmpq %rdx, 0x8(%r9)
je 0xc0598
movq 0x18(%r9), %r9
jmp 0xc0583
movq 0x10(%r9), %rdi
testb %r8b, %r8b
je 0xc04fe
movq 0x10(%rsi), %rsi
cmpb $0x1c, (%rsi)
je 0xc057f
movq 0x10(%rdx), %rdx
cmpb $0x20, (%rdx)
je 0xc04fa
xorl %edi, %edi
jmp 0xc04fe
// File: /workspace/github_c_makefile_star2_O1/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 0xc0617
jle 0xc0612
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rdi
jl 0xc0605
cmpq %rdi, %r8
jne 0xc0677
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq 0x8(%rax), %rdx
movq %rdi, 0x10(%rdx)
movq 0x8(%rdx), %rdi
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
incl 0x28(%rdi)
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 0xc06a7
movq 0x8(%rdx), %r9
testq %r9, %r9
sete %r8b
je 0xc0699
cmpq %rcx, 0x8(%r9)
je 0xc0695
movq 0x18(%r9), %r9
jmp 0xc0680
movq 0x10(%r9), %rdi
testb %r8b, %r8b
je 0xc061f
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xc067c
movq 0x10(%rcx), %rcx
cmpb $0x20, (%rcx)
je 0xc061b
xorl %edi, %edi
jmp 0xc061f
// File: /workspace/github_c_makefile_star2_O1/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 0xc0722
jle 0xc0719
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %r8
cmpq %r8, %rdi
jl 0xc070c
cmpq %rdi, %r8
jne 0xc07a2
movq 0x18(%rdx), %rdx
movq 0x10(%rdx), %rdi
movq 0x250(%rbx), %rdx
incq %rdx
movq %rdx, 0x250(%rbx)
movq %rdx, 0x18(%rcx)
movq 0x8(%rcx), %rsi
movq %rdi, 0x10(%rsi)
movq 0x8(%rsi), %rdi
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
incl 0x28(%rdi)
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 0xc07d6
movq 0x8(%rsi), %r9
testq %r9, %r9
sete %r8b
je 0xc07c4
cmpq %rdx, 0x8(%r9)
je 0xc07c0
movq 0x18(%r9), %r9
jmp 0xc07ab
movq 0x10(%r9), %rdi
testb %r8b, %r8b
je 0xc072a
movq 0x10(%rsi), %rsi
cmpb $0x1c, (%rsi)
je 0xc07a7
movq 0x10(%rdx), %rdx
cmpb $0x20, (%rdx)
je 0xc0726
xorl %edi, %edi
jmp 0xc072a
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_add_aa
static s7_pointer fx_add_aa(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer a1, a2;
                    a1 = cdr(arg);
                    a2 = cdr(a1);
                    return(add_p_pp(sc, fx_call(sc, a1), fx_call(sc, a2)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %r15
callq *0x20(%rax)
movq %rax, %r14
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x8d0a7
// File: /workspace/github_c_makefile_star2_O1/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 0xc09b4
jle 0xc09af
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xc09a2
cmpq %rdx, %rsi
jne 0xc09dc
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x570(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xc0a0c
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %sil
je 0xc09fe
cmpq %rax, 0x8(%rdi)
je 0xc09fa
movq 0x18(%rdi), %rdi
jmp 0xc09e5
movq 0x10(%rdi), %rdx
testb %sil, %sil
je 0xc09bc
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xc09e1
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xc09b8
xorl %edx, %edx
jmp 0xc09bc
// File: /workspace/github_c_makefile_star2_O1/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 0xc0aa0
jle 0xc0a9b
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xc0a8e
cmpq %rdx, %rsi
jne 0xc0ac8
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x578(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xc0af8
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %sil
je 0xc0aea
cmpq %rax, 0x8(%rdi)
je 0xc0ae6
movq 0x18(%rdi), %rdi
jmp 0xc0ad1
movq 0x10(%rdi), %rdx
testb %sil, %sil
je 0xc0aa8
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xc0acd
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xc0aa4
xorl %edx, %edx
jmp 0xc0aa8
// File: /workspace/github_c_makefile_star2_O1/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 0xc0b21
movq %rbx, %rdi
callq 0xc15d0
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_O1/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 0xc0bb4
movq %rbx, %rdi
callq 0xc15d0
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 0xc0c06
jle 0xc0c01
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xc0bf4
cmpq %rdx, %rsi
jne 0xc0c47
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x570(%rbx), %rax
movq %rdx, 0x8(%rax)
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 0xc0c77
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %sil
je 0xc0c69
cmpq %rax, 0x8(%rdi)
je 0xc0c65
movq 0x18(%rdi), %rdi
jmp 0xc0c50
movq 0x10(%rdi), %rdx
testb %sil, %sil
je 0xc0c0e
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xc0c4c
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xc0c0a
xorl %edx, %edx
jmp 0xc0c0e
// File: /workspace/github_c_makefile_star2_O1/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 0xc0ca1
movq %rbx, %rdi
callq 0xc15d0
movq 0x10(%r14), %rax
movq 0x8(%rax), %r15
movq 0x50(%rbx), %rax
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_O1/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 0xc0d8c
jle 0xc0d83
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rdi
jl 0xc0d76
cmpq %rdi, %r8
jne 0xc0e0e
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq 0x8(%rax), %rdx
movq %rdi, 0x10(%rdx)
movq 0x8(%rdx), %rdi
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
incl 0x28(%rdi)
movq %rax, 0x8(%rbx)
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xc0df1
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 0xc0df8
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
cmpb $0x1c, (%rdx)
jne 0xc0e42
movq 0x8(%rdx), %r9
testq %r9, %r9
sete %r8b
je 0xc0e30
cmpq %rcx, 0x8(%r9)
je 0xc0e2c
movq 0x18(%r9), %r9
jmp 0xc0e17
movq 0x10(%r9), %rdi
testb %r8b, %r8b
je 0xc0d94
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xc0e13
movq 0x10(%rcx), %rcx
cmpb $0x20, (%rcx)
je 0xc0d90
xorl %edi, %edi
jmp 0xc0d94
// File: /workspace/github_c_makefile_star2_O1/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 0xc0eb2
jle 0xc0ea9
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rdi
jl 0xc0e9c
cmpq %rdi, %r8
jne 0xc0f38
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq 0x8(%rax), %rdx
movq %rdi, 0x10(%rdx)
movq 0x8(%rdx), %rdi
movq %rdx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
incl 0x28(%rdi)
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 0xc0f1c
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 0xc0f6c
movq 0x8(%rdx), %r9
testq %r9, %r9
sete %r8b
je 0xc0f5a
cmpq %rcx, 0x8(%r9)
je 0xc0f56
movq 0x18(%r9), %r9
jmp 0xc0f41
movq 0x10(%r9), %rdi
testb %r8b, %r8b
je 0xc0eba
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xc0f3d
movq 0x10(%rcx), %rcx
cmpb $0x20, (%rcx)
je 0xc0eb6
xorl %edi, %edi
jmp 0xc0eba
// File: /workspace/github_c_makefile_star2_O1/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 0xc0fa6
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0xc0fcb
cmpq %rdx, 0x8(%rax)
je 0xc0fd4
movq 0x18(%rax), %rax
jmp 0xc0f95
movq 0x1230(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x8d9a0(%rip), %rdx     # 0x14e958
movq 0x140(%rdi), %r8
movq 0x91992(%rip), %r9      # 0x152958
jmp 0xb31d
movq 0x10(%rcx), %rsi
jmp 0xc24a7
movq 0x10(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc1002
jle 0xc0ffd
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xc0ff0
cmpq %rdx, %r8
jne 0xc105e
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x10(%rdx), %rcx
cmpb $0x1c, (%rcx)
jne 0xc1030
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0xc1055
cmpq %rdx, 0x8(%rax)
je 0xc1097
movq 0x18(%rax), %rax
jmp 0xc101f
movq 0x1230(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x8d916(%rip), %rdx     # 0x14e958
movq 0x140(%rdi), %r8
movq 0x91908(%rip), %r9      # 0x152958
jmp 0xb31d
movq 0x10(%rcx), %rsi
jmp 0xc24a7
cmpb $0x1c, (%rcx)
jne 0xc108e
movq 0x8(%rcx), %r9
testq %r9, %r9
sete %r8b
je 0xc1080
cmpq %rax, 0x8(%r9)
je 0xc107c
movq 0x18(%r9), %r9
jmp 0xc1067
movq 0x10(%r9), %rdx
testb %r8b, %r8b
je 0xc100a
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xc1063
movq 0x10(%rax), %rax
jmp 0xc1006
movq 0x10(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc10fb
movq 0x10(%rax), %rcx
cmpq 0x110(%rdi), %rcx
je 0xc113e
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 0x5f618(%rip), %rcx     # 0x1206fa
movq %rcx, 0x10(%rax)
movq $0x1c, 0x8(%rax)
movq 0x6e0(%rdi), %rcx
movq %rax, 0x8(%rcx)
jmp 0xc1162
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 0xc1144
leaq 0x5f5b4(%rip), %rax     # 0x1206e4
movq %rax, 0x10(%rcx)
movq $0x15, 0x8(%rcx)
jmp 0xc1157
movq 0x8(%rax), %rbx
jmp 0xc1180
leaq 0x5f579(%rip), %rax     # 0x1206c4
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 0x3b366
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc124e
cmpb $0x1, 0x24c(%rbx)
jne 0xc124e
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq %rax, %r12
movq 0xf58(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xc11ed
movq %rbx, %rdi
callq 0xb389
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 0x967ca
cmpq 0x120(%rbx), %rax
setne %al
jmp 0xc127b
movq 0xf58(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x8d700(%rip), %rdx     # 0x14e960
movq 0x140(%rbx), %r8
movq 0x9185a(%rip), %r9      # 0x152ac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xb31d
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_O1/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 0xc134a
cmpb $0x1, 0x24c(%rbx)
jne 0xc134a
movq %rdx, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq %rax, %r12
movq 0xf58(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xc12e9
movq %rbx, %rdi
callq 0xb389
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 0x967ca
cmpq 0x120(%rbx), %rax
setne %al
jmp 0xc1377
movq 0xf58(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x8d5fc(%rip), %rdx     # 0x14e958
movq 0x140(%rbx), %r8
movq 0x9175e(%rip), %r9      # 0x152ac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xb31d
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_O1/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 0xc1a79
leaq 0x4fc3a(%rip), %rcx     # 0x1115a8
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 0xc19a5
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xb389
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 0xc1a6b
addsd 0x8(%r14), %xmm0
jmp 0xc1a25
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 0xe101
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 0xc1a49
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0xc1aa4
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0xc1ae8
movq %rbx, %rdi
callq 0xb389
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 0x9b86a(%rip), %r8      # 0x15d3a0
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 0xf3da
// File: /workspace/github_c_makefile_star2_O1/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 0xc1c3d
leaq 0x4fa3d(%rip), %rcx     # 0x1115b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
movq %rax, %r14
incq %r14
jno 0xc1cab
cvtsi2sd %rax, %xmm0
jmp 0xc1ba1
movsd 0x8(%r14), %xmm0
addsd 0x4d487(%rip), %xmm0    # 0x10f030
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc1bcb
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
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 0x4d429(%rip), %xmm0    # 0x10f030
movsd 0x10(%r14), %xmm1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe101
movq 0x8cd31(%rip), %rdx     # 0x14e958
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc1d02
movq 0xba8(%rbx), %r15
movq 0x10(%rdx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc1c60
movq %rbx, %rdi
callq 0xb389
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 0x9b714(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf3da
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xc1cc4
leaq 0x8cc95(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0xc1bed
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc1cdc
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xc1bed
// File: /workspace/github_c_makefile_star2_O1/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 0xc1d4c
addq %rsi, %rcx
movq %rbx, %rdi
movq %rcx, %rsi
addq $0x30, %rsp
popq %rbx
jmp 0xdd7f
movq %rdx, %rax
imulq %r8, %rax
jo 0xc1d6c
movq %rsi, %r9
imulq %r8, %r9
jo 0xc1d6c
movq %rcx, %rdi
imulq %rdx, %rdi
jo 0xc1d6c
addq %rdi, %r9
jno 0xc1dea
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 0xc1dc2
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
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 0xc1d42
// File: /workspace/github_c_makefile_star2_O1/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 0xc1edd
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movsd 0x8(%rcx), %xmm2
leaq 0x4f79e(%rip), %rcx     # 0x1115c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq 0x8(%rsi), %xmm0
jmp 0xc1e40
movsd 0x8(%rsi), %xmm0
subsd %xmm2, %xmm0
jmp 0xc1e91
movsd 0x8(%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
subsd %xmm2, %xmm0
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0xe101
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 0xc1eb5
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0x9b4b5(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
movl $0x1, %r9d
addq $0x30, %rsp
popq %rbx
jmp 0xf3da
// File: /workspace/github_c_makefile_star2_O1/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 0xc22e0
leaq 0x4f44a(%rip), %rcx     # 0x1115e8
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 0xc21d8
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
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 0xc22d2
mulsd 0x8(%r14), %xmm1
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc2229
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xb389
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 0xc22d2
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 0xe101
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 0xc22b0
movq %rbx, %rdi
movsd %xmm2, 0x8(%rsp)
callq 0xb389
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 0xc230b
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xb389
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 0xc234f
movq %rbx, %rdi
callq 0xb389
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 0x9b003(%rip), %r8      # 0x15d3a0
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 0xf3da
// File: /workspace/github_c_makefile_star2_O1/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 0xc23df
movq %rdx, %r14
cmpl $0xd, %eax
je 0xc23e8
cmpl $0xc, %eax
jne 0xc240e
movq 0x120(%rbx), %rax
jmp 0xc2404
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 0xc243c
movq %rbx, %rdi
callq 0xb389
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 0x9af16(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3da
// File: /workspace/github_c_makefile_star2_O1/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 0xc24cd
movq %rsi, %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xc24c4
cmpq %rdx, 0x8(%rcx)
je 0xc24e4
movq 0x18(%rcx), %rcx
jmp 0xc24b3
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
je 0xc24af
movq (%rsi), %rax
btl $0x1e, %eax
jb 0xc24e9
movq 0x10(%rdx), %rax
cmpb $0x20, (%rax)
jne 0xc24f7
movq 0x10(%rax), %rax
retq
movq 0x10(%rcx), %rax
retq
notl %eax
testl $0x44000000, %eax       # imm = 0x44000000
jne 0xc24f7
jmp 0xc5b7
movq 0x128(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc2824
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xc2824
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
movq (%rax), %rcx
leaq -0x19dae(%rip), %r8     # 0xa89e7
cmpq %r8, %rcx
setne %r8b
leaq 0x200(%rip), %r9        # 0xc29a3
cmpq %r9, %rcx
setne %cl
andb %r8b, %cl
jne 0xc2824
movq 0x10(%rsi), %r8
movq %r8, 0x28(%rsi)
movq 0x18(%rax), %r8
movq %r8, 0x20(%rsi)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsi)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
testq %rdx, %rdx
je 0xc27f2
leaq -0x34b1e(%rip), %rax    # 0x8dcbc
cmpq %rax, 0x18(%rsi)
leaq 0x1db(%rip), %rdx       # 0xc29c0
leaq 0x1f9(%rip), %rax       # 0xc29e5
cmoveq %rdx, %rax
jmp 0xc27f9
leaq 0x225(%rip), %rax       # 0xc2a1e
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
testb %cl, %cl
je 0xc2826
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaa24
movq 0x8(%rbx), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%r14), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0xc2acd
jle 0xc2a91
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0xc2a84
cmpq %rsi, %rdi
je 0xc2acd
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xc2acd
movq 0x8(%rdx), %r15
testq %r15, %r15
sete %dil
je 0xc2ab9
cmpq %r14, 0x8(%r15)
je 0xc2abc
movq 0x18(%r15), %r15
jmp 0xc2aa4
movq %rsi, %r15
testb %dil, %dil
je 0xc2ad1
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %r15, %rsi
je 0xc2aa0
movq (%r14,%rcx), %r15
cmpb $0x20, (%r15)
jne 0xc2b01
movq 0x10(%r15), %rcx
movq 0x700(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x700(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbd41
cmpq 0x118(%rbx), %rax
je 0xc2b04
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_i_iii_fff
static s7_int opt_i_iii_fff(opt_info *o)
                {
                    opt_info *o1;
                    s7_int i1, i2;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    i1 = o1->v[0].fi(o1);
                    o1 = sc->opts[++sc->pc];
                    i2 = o1->v[0].fi(o1);
                    o1 = sc->opts[++sc->pc];
                    oo_rc(sc, o, 4, 0);
                    return(o->v[3].i_iii_f(i1, i2, o1->v[0].fi(o1)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r12
movslq 0x2258(%r12), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r12)
movq 0x2268(%r12,%rax,8), %rdi
callq *(%rdi)
movq %rax, %r14
movslq 0x2258(%r12), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r12)
movq 0x2268(%r12,%rax,8), %rdi
callq *(%rdi)
movq %rax, %r15
movslq 0x2258(%r12), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r12)
movq 0x2268(%r12,%rax,8), %rdi
movq 0x18(%rbx), %rbx
callq *(%rdi)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax