LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_i_add2
static s7_int opt_i_add2(opt_info *o)
                {
                    opt_info *o1;
                    s7_int sum;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    sum = o1->v[0].fi(o1);
                    o1 = sc->opts[++sc->pc];
                    return(sum + o1->v[0].fi(o1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movq %rax, %rbx
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc2e7d
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 0xc2e50
jmp 0xc2e80
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc2ece
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 0xc2ea0
jmp 0xc2ed3
movl $0x1, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_7pii_sff
static s7_double opt_d_7pii_sff(opt_info *o)
                {
                    opt_info *o1;
                    s7_int i1;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    i1 = o1->v[0].fi(o1);
                    o1 = sc->opts[++sc->pc];
                    oo_rc(sc, o, 5, 1);
                    return(o->v[4].d_7pii_f(sc, slot_value(o->v[1].p), i1, o1->v[0].fi(o1)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movq %rax, %r15
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movq 0x8(%rbx), %rax
movq 0x20(%rbx), %r12
movq 0x10(%rax), %rbx
callq *(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 0xc3255
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xc3255
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq -0x1c155(%rip), %rcx    # 0xa70fb
cmpq %rcx, (%rax)
je 0xc3258
xorl %eax, %eax
retq
testq %rdx, %rdx
leaq 0xa1c(%rip), %rcx       # 0xc3c7e
leaq 0x9c8(%rip), %rdx       # 0xc3c31
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)
movabsq $0x300000006, %rax      # imm = 0x300000006
movq %rax, 0x60(%rsi)
movq $0x2, 0x70(%rsi)
movl $0x1, 0x78(%rsi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: d_dd_fs_combinable
static bool d_dd_fs_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_fso;
                            }
                            else
                            {
                                opc->v[4].d_7dd_f = opc->v[3].d_7dd_f;
                                opc->v[0].fd = opt_d_7dd_fso;
                            }
                            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 0xc34b2
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xc34b2
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq -0x1c3b2(%rip), %rcx    # 0xa70fb
cmpq %rcx, (%rax)
je 0xc34b5
xorl %eax, %eax
retq
testq %rdx, %rdx
leaq 0x811(%rip), %rcx       # 0xc3cd0
leaq -0x1c350(%rip), %rdx    # 0xa7176
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)
movabsq $0x300000006, %rax      # imm = 0x300000006
movq %rax, 0x60(%rsi)
movq $0x2, 0x70(%rsi)
movl $0x1, 0x78(%rsi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_dd_ff_mul
static s7_double opt_d_dd_ff_mul(opt_info *o)
                {
                    opt_info *o1, *o2;
                    s7_double x1;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 4, 0);
                    o1 = sc->opts[++sc->pc];
                    x1 = o1->v[0].fd(o1);
                    o2 = sc->opts[++sc->pc];
                    return(x1 * o2->v[0].fd(o2));
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x68(%rdi), %rbx
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, 0x8(%rsp)
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
mulsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_dd_ff_add_mul
static s7_double opt_d_dd_ff_add_mul(opt_info *o)
                {
                    s7_double x1, x2;
                    opt_info *o2;
                    oo_rc(o->sc, o, 12, 0);
                    o->sc->pc++;                  /* local sc made no difference */
                    x1 = o->v[5].fd(o->v[4].o1);
                    o->sc->pc += 2;
                    x2 = o->v[11].fd(o->v[10].o1);
                    o2 = o->sc->opts[++o->sc->pc];
                    return(x1 + (x2 * o2->v[0].fd(o2)));
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rax
incl 0x2258(%rax)
movq 0x20(%rdi), %rdi
callq *0x28(%rbx)
movsd %xmm0, 0x8(%rsp)
movq 0x68(%rbx), %rax
addl $0x2, 0x2258(%rax)
movq 0x50(%rbx), %rdi
callq *0x58(%rbx)
movsd %xmm0, (%rsp)
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
mulsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_dd_ff_add_fv_ref
static s7_double opt_d_dd_ff_add_fv_ref(opt_info *o)
                {
                    opt_info *o1, *o2;
                    s7_double x1;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 4, 0);
                    o1 = sc->opts[++sc->pc];
                    x1 = o1->v[0].fd(o1);
                    o1 = sc->opts[++sc->pc];
                    o2 = sc->opts[++sc->pc];
                    return(x1 + float_vector_ref_d_7pi(sc, slot_value(o1->v[1].p), o2->v[0].fi(o2)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rbx
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, (%rsp)
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rcx
leaq 0x2(%rax), %rdx
movl %edx, 0x2258(%rbx)
movq 0x2270(%rbx,%rax,8), %rdi
movq 0x8(%rcx), %rax
movq 0x10(%rax), %r14
callq *(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x87054
addsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_dd_ff_add
static s7_double opt_d_dd_ff_add(opt_info *o)
                {
                    s7_double x1;
                    oo_rc(o->sc, o, 12, 0);
                    o->sc->pc++;
                    x1 = o->v[5].fd(o->v[4].o1);
                    o->sc->pc++;
                    return(x1 + o->v[11].fd(o->v[10].o1));
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rax
incl 0x2258(%rax)
movq 0x20(%rdi), %rdi
callq *0x28(%rbx)
movsd %xmm0, 0x8(%rsp)
movq 0x68(%rbx), %rax
incl 0x2258(%rax)
movq 0x50(%rbx), %rdi
callq *0x58(%rbx)
addsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_7dd_ff
static s7_double opt_d_7dd_ff(opt_info *o)
                {
                    opt_info *o1, *o2;
                    s7_double x1;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 4, 0);
                    o1 = sc->opts[++sc->pc];
                    x1 = o1->v[0].fd(o1);
                    o2 = sc->opts[++sc->pc];
                    return(o->v[3].d_7dd_f(sc, x1, o2->v[0].fd(o2)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, (%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movq 0x18(%rbx), %rbx
callq *(%rdi)
movaps %xmm0, %xmm1
movq %r14, %rdi
movsd (%rsp), %xmm0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_dd_fff
static s7_double opt_d_dd_fff(opt_info *o)
                {
                    opt_info *o1, *o2;
                    s7_double x1, x2;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    x1 = o1->v[4].d_dd_f(o1->v[5].d_7pi_f(sc, slot_value(o1->v[2].p), integer(slot_value(o1->v[3].p))), real(slot_value(o1->v[1].p))); /* dd_fso */
                    o2 = sc->opts[++sc->pc];
                    x2 = o2->v[4].d_dd_f(o2->v[5].d_7pi_f(sc, slot_value(o2->v[2].p), integer(slot_value(o2->v[3].p))), real(slot_value(o2->v[1].p))); /* dd_fso */
                    oo_rc(sc, o, 4, 0);
                    return(o->v[3].d_dd_f(x1, x2));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %r15
movq 0x20(%r15), %r12
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
movq 0x10(%rax), %rsi
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq *0x28(%r15)
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm1
callq *%r12
movsd %xmm0, (%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %r15
movq 0x20(%r15), %r12
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
movq 0x10(%rax), %rsi
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq *0x28(%r15)
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm1
callq *%r12
movaps %xmm0, %xmm1
movq 0x18(%rbx), %rax
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_dd_fff_rev
static s7_double opt_d_dd_fff_rev(opt_info *o) /* faster with o->sc? */
                {
                    opt_info *o1, *o2;
                    s7_double x1, x2;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    x1 = o1->v[4].d_dd_f(real(slot_value(o1->v[1].p)), o1->v[5].d_7pi_f(sc, slot_value(o1->v[2].p), integer(slot_value(o1->v[3].p))));
                    o2 = sc->opts[++sc->pc];
                    x2 = o2->v[4].d_dd_f(real(slot_value(o2->v[1].p)), o2->v[5].d_7pi_f(sc, slot_value(o2->v[2].p), integer(slot_value(o2->v[3].p))));
                    oo_rc(sc, o, 4, 0);
                    return(o->v[3].d_dd_f(x1, x2));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rax
movq 0x20(%rax), %r15
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
movq 0x10(%rcx), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rdx), %rsi
movq 0x18(%rax), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq %r14, %rdi
callq *0x28(%rax)
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq *%r15
movsd %xmm0, (%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rax
movq 0x20(%rax), %r15
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
movq 0x10(%rcx), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rdx), %rsi
movq 0x18(%rax), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq %r14, %rdi
callq *0x28(%rax)
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq *%r15
movaps %xmm0, %xmm1
movq 0x18(%rbx), %rax
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_7pi_ff
static s7_double opt_d_7pi_ff(opt_info *o)
                {
                    s7_pointer seq;
#if 0
                    opt_info *o1;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 10, 0);
                    o1 = sc->opts[++sc->pc];
                    seq = o1->v[0].fp(o1);
#else
                    oo_rc(o->sc, o, 10, 0);
                    o->sc->pc++;
                    seq = o->v[5].fp(o->v[4].o1);
#endif
#if 0
                    o1 = sc->opts[++sc->pc];
                    return(o->v[3].d_7pi_f(sc, seq, o1->v[0].fi(o1)));
#else
                    o->sc->pc++;
                    return(o->v[3].d_7pi_f(o->sc, seq, o->v[9].fi(o->v[8].o1)));
#endif
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
incl 0x2258(%rax)
movq 0x20(%rdi), %rdi
callq *0x28(%rbx)
movq 0x68(%rbx), %r14
incl 0x2258(%r14)
movq %rax, %r15
movq 0x18(%rbx), %r12
movq 0x40(%rbx), %rdi
callq *0x48(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_ddd_sff
static s7_double opt_d_ddd_sff(opt_info *o)
                {
                    opt_info *o1;
                    s7_double x1;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    x1 = o1->v[0].fd(o1);
                    o1 = sc->opts[++sc->pc];
                    oo_rc(sc, o, 5, 1);
                    return(o->v[4].d_ddd_f(real(slot_value(o->v[1].p)), x1, o1->v[0].fd(o1)));
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, 0x10(%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movq 0x8(%rbx), %rax
movq 0x20(%rbx), %rbx
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq *(%rdi)
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_ddd_fff
static s7_double opt_d_ddd_fff(opt_info *o)
                {
                    opt_info *o1, *o2, *o3;
                    s7_double x1, x2;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    x1 = o1->v[0].fd(o1); /* this could involve nested funcs, incrementing pc internally */
                    o2 = sc->opts[++sc->pc];
                    x2 = o2->v[0].fd(o2);
                    o3 = sc->opts[++sc->pc];
                    oo_rc(o->sc, o, 5, 0);
                    return(o->v[4].d_ddd_f(x1, x2, o3->v[0].fd(o3)));
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, 0x10(%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, 0x8(%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movq 0x20(%rbx), %rbx
callq *(%rdi)
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_ddd_fff1
static s7_double opt_d_ddd_fff1(opt_info *o)
                {
                    s7_double x1, x2, x3;
                    x1 = o->v[1].d_v_f(o->v[2].obj);
                    x2 = o->v[3].d_v_f(o->v[4].obj);
                    x3 = o->v[5].d_v_f(o->v[6].obj);
                    oo_rc(o->sc, o, 8, 3);
                    return(o->v[7].d_ddd_f(x1, x2, x3));
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq *0x8(%rbx)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
callq *0x18(%rbx)
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
callq *0x28(%rbx)
movaps %xmm0, %xmm2
movq 0x38(%rbx), %rax
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
addq $0x10, %rsp
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_ddd_fff2
static s7_double opt_d_ddd_fff2(opt_info *o)
                {
                    opt_info *o2, *o3;
                    s7_double x1, x2;
                    s7_scheme *sc;
                    sc = o->sc;
                    x1 = o->v[1].d_v_f(o->v[2].obj);
                    sc->pc += 2;
                    o2 = sc->opts[sc->pc];
                    x2 = o2->v[0].fd(o2);
                    o3 = sc->opts[++sc->pc];
                    oo_rc(sc, o, 8, 1);
                    return(o->v[7].d_ddd_f(x1, x2, o3->v[0].fd(o3)));
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x68(%rbx), %r14
callq *0x8(%rbx)
movsd %xmm0, 0x10(%rsp)
movslq 0x2258(%r14), %rax
leaq 0x2(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2270(%r14,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, 0x8(%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movq 0x38(%rbx), %rbx
callq *(%rdi)
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_fmv
static inline s7_double opt_fmv(opt_info *o)
                {
                    /* d_vid_ssf -> d_dd_ff_o1 -> d_vd_o1 -> d_dd_ff_o3 */
                    opt_info *o1, *o2, *o3;
                    s7_double amp_env, index_env, vib;
                    s7_scheme *sc;
                    sc = o->sc;

                    o1 = sc->opts[sc->pc + 1];
                    o2 = sc->opts[sc->pc + 3];
                    o3 = sc->opts[sc->pc += 5];
                    amp_env = o1->v[2].d_v_f(o1->v[1].obj);
                    vib = real(slot_value(o2->v[2].p));
                    index_env = o3->v[5].d_v_f(o3->v[1].obj);

                    oo_rc(o->sc, o, 6, 2);
                    return(o->v[4].d_vid_f(o->v[5].obj,
                                integer(slot_value(o->v[2].p)),
                                amp_env * o2->v[3].d_vd_f(o2->v[5].obj,
                                    vib + (index_env * o3->v[6].d_vd_f(o3->v[2].obj, vib)))));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
movq 0x2268(%rax,%rcx,8), %rdx
movq 0x2278(%rax,%rcx,8), %r15
leaq 0x5(%rcx), %rsi
movl %esi, 0x2258(%rax)
movq 0x2288(%rax,%rcx,8), %r12
movq 0x8(%rdx), %rdi
callq *0x10(%rdx)
movsd %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%r12), %rdi
callq *0x28(%r12)
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rbp
movq 0x28(%rbx), %rbx
movq 0x10(%rax), %rax
movq 0x8(%rax), %r14
movq 0x18(%r15), %r13
movq 0x28(%r15), %r15
movq 0x10(%r12), %rdi
movsd (%rsp), %xmm0
callq *0x30(%r12)
mulsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movq %r15, %rdi
callq *%r13
mulsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_vdd_ff
static s7_double opt_d_vdd_ff(opt_info *o)
                {
                    opt_info *o1, *o2;
                    s7_double x1;
                    o1 = o->sc->opts[++o->sc->pc];
                    x1 = o1->v[0].fd(o1);
                    o2 = o->sc->opts[++o->sc->pc];
                    oo_rc(o->sc, o, 6, 1);
                    return(o->v[4].d_vdd_f(o->v[5].obj, x1, o2->v[0].fd(o2)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movsd %xmm0, (%rsp)
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %rbx
callq *(%rdi)
movaps %xmm0, %xmm1
movq %rbx, %rdi
movsd (%rsp), %xmm0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_dddd_ffff
static s7_double opt_d_dddd_ffff(opt_info *o)
                {
                    opt_info *o1, *o2, *o3, *o4;
                    s7_double x1, x2, x3;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    x1 = o1->v[0].fd(o1);
                    o2 = sc->opts[++sc->pc];
                    x2 = o2->v[0].fd(o2);
                    o3 = sc->opts[++sc->pc];
                    x3 = o3->v[0].fd(o3);
                    o4 = sc->opts[++sc->pc];
                    oo_rc(o->sc, o, 1, 0);
                    return(o->v[1].d_dddd_f(x1, x2, x3, o4->v[0].fd(o4)));
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, 0x10(%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, 0x8(%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movsd %xmm0, (%rsp)
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movq 0x8(%rbx), %rbx
callq *(%rdi)
movaps %xmm0, %xmm3
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_add_any_f
static s7_double opt_d_add_any_f(opt_info *o)
                {
                    s7_double sum = 0.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].fd(o1);
                    }
                    return(sum);
                }

// Assembly:
cmpq $0x0, 0x8(%rdi)
jle 0xc4aa0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movsd %xmm0, (%rsp)
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
cmpq %r14, 0x8(%rbx)
jg 0xc4a58
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_multiply_any_f
static s7_double opt_d_multiply_any_f(opt_info *o)
                {
                    s7_double sum = 1.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].fd(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
jle 0xc4aff
movq %rdi, %rbx
movsd 0x4a576(%rip), %xmm0    # 0x10f030
xorl %r14d, %r14d
movsd %xmm0, (%rsp)
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
cmpq %r14, 0x8(%rbx)
jg 0xc4abd
jmp 0xc4b07
movsd 0x4a529(%rip), %xmm0    # 0x10f030
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_subtract_any_f
static s7_double opt_d_subtract_any_f(opt_info *o)
                {
                    opt_info *o1;
                    s7_double sum;
                    int32_t i;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(o->sc, o, 2, 0);
                    o1 = sc->opts[++sc->pc];
                    sum = o1->v[0].fd(o1);
                    for (i = 1; i < o->v[1].i; i++)
                    {
                        o1 = sc->opts[++sc->pc];
                        sum -= o1->v[0].fd(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
cmpq $0x2, 0x8(%rbx)
jl 0xc4b88
movl $0x1, %r15d
movsd %xmm0, 0x8(%rsp)
movslq 0x2258(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r15
cmpq %r15, 0x8(%rbx)
jg 0xc4b48
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: copy_list_with_arglist_error
static s7_pointer copy_list_with_arglist_error(s7_scheme *sc, s7_pointer lst)
                {
                    s7_pointer p, tp, np;
                    if (is_null(lst)) return(sc->nil);
                    if (!is_pair(lst))
                        s7_error(sc, sc->syntax_error_symbol, set_elist_2(sc, wrap_string(sc, "stray dot?: ~S", 14), lst));
                    sc->u = lst;
                    tp = cons(sc, car(lst), sc->nil);
                    sc->y = tp;
                    for (p = cdr(lst), np = tp; is_pair(p); p = cdr(p), np = cdr(np))
                        set_cdr(np, cons(sc, car(p), sc->nil));
                    sc->y = sc->nil;
                    sc->u = sc->nil;
                    if (!is_null(p))
                        s7_error(sc, sc->syntax_error_symbol, set_elist_2(sc, wrap_string(sc, "improper list of arguments: ~S", 30), lst));
                    return(tp);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x110(%rdi), %r15
cmpq %rsi, %r15
je 0xc4d5a
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
je 0xc4c18
movq 0x1918(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x5bb34(%rip), %rcx     # 0x120717
movq %rcx, 0x10(%rax)
movq $0xe, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
movq %r14, 0x4c8(%rbx)
movq 0x8(%r14), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xc4c42
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r12, 0x8(%r15)
movq %r13, 0x10(%r15)
movq %r15, 0x4e8(%rbx)
movq %r14, (%rsp)
movq 0x10(%r14), %r12
cmpb $0x1, (%r12)
jne 0xc4cdc
movq %r15, %r13
movq 0x8(%r12), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0xc4ca4
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
movq %rax, %r13
je 0xc4c80
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
cmpq %rax, %r12
je 0xc4d5a
movq 0x1918(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x5ba05(%rip), %rcx     # 0x120726
movq %rcx, 0x10(%rax)
movq $0x1e, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
movq %r15, %rax
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: c_function_is_ok
static bool c_function_is_ok(s7_scheme *sc, s7_pointer x)
                {
                    /* macro version of this (below) is much slower! Since this is almost never false,
                     *   I tried __builtin_expect throughout eval below.  The result was not faster.
                     */
                    s7_pointer p;

                    p = car(x);               /* function name (symbol) */
                    if (is_global(p))
                        p = slot_value(global_slot(p));
                    else p = lookup_checked(sc, p);

                    /* this is nearly always global and p == opt1_cfunc(x)
                     * p can be null if we evaluate some code, optimizing it, then eval it again in a context
                     *   where the incoming p was undefined(!) -- explicit use of eval and so on.
                     *   I guess ideally eval would ignore optimization info -- copy :readable or something.
                     */
                    return((p == opt1_any(x)) ||
                            ((is_any_c_function(p)) &&
                             (c_function_class(p) == c_function_class(opt1_cfunc(x)))));
                }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
testb $0x1, 0x2(%rsi)
jne 0xc4f21
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdx
movq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0xc4f0d
jle 0xc4f08
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jl 0xc4efb
cmpq %rax, %rdx
jne 0xc4f52
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xc4f29
callq 0xa2ee9
jmp 0xc4f29
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0xc4f4a
cmpb $0x2f, (%rax)
jb 0xc4f4e
movq 0x8(%rax), %rax
movl 0xc(%rax), %eax
movq 0x8(%rcx), %rcx
cmpl 0xc(%rcx), %eax
sete %al
jmp 0xc4f50
movb $0x1, %al
jmp 0xc4f50
xorl %eax, %eax
popq %rbx
retq
cmpb $0x1c, (%rcx)
jne 0xc4f80
movq 0x8(%rcx), %r8
testq %r8, %r8
sete %dl
je 0xc4f73
cmpq %rsi, 0x8(%r8)
je 0xc4f6f
movq 0x18(%r8), %r8
jmp 0xc4f5b
movq 0x10(%r8), %rax
testb %dl, %dl
je 0xc4f15
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xc4f57
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xc4f11
xorl %eax, %eax
jmp 0xc4f15
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_all_s
static s7_pointer fx_c_all_s(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer args, p, lst;
                    lst = safe_list_if_possible(sc, integer(opt3_arglen(arg)));
                    if (in_heap(lst))
                        gc_protect_direct(sc, lst);
                    for (args = cdr(arg), p = lst; is_pair(args); args = cdr(args), p = cdr(p))
                        set_car(p, lookup(sc, car(args)));
                    p = c_call(arg)(sc, lst);
                    if (in_heap(lst))
                        sc->stack_end -= 4;
                    else clear_list_in_use(lst);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rsi
cmpq $0x7, %rsi
jg 0xc4fcc
movq 0x1f38(%rbx,%rsi,8), %rax
testb $0x4, 0x1(%rax)
jne 0xc4fcc
movl %esi, 0x2138(%rbx)
orb $0x4, 0x1(%rax)
movq 0x1f38(%rbx,%rsi,8), %r15
jmp 0xc4fd7
movq %rbx, %rdi
callq 0xb587f
movq %rax, %r15
testb $0x40, 0x7(%r15)
jne 0xc4ffa
movq 0x50(%rbx), %rax
movq $0x1, 0x18(%rax)
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r15, 0x10(%rax)
movq 0x10(%r14), %rax
cmpb $0x1, (%rax)
jne 0xc508b
movq %r15, %rcx
movq 0x8(%rax), %rdx
movq 0x8(%rbx), %rsi
movq 0x18(%rsi), %r8
movq 0x20(%rdx), %rdi
cmpq %rdi, %r8
je 0xc5033
jle 0xc502e
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %r8
cmpq %r8, %rdi
jl 0xc5021
cmpq %rdi, %r8
jne 0xc504e
movq 0x18(%rdx), %rdx
movq 0x10(%rdx), %rdi
movq %rdi, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xc500a
jmp 0xc508b
cmpb $0x1c, (%rsi)
jne 0xc507e
movq 0x8(%rsi), %r9
testq %r9, %r9
sete %r8b
je 0xc5070
cmpq %rdx, 0x8(%r9)
je 0xc506c
movq 0x18(%r9), %r9
jmp 0xc5057
movq 0x10(%r9), %rdi
testb %r8b, %r8b
je 0xc503b
movq 0x10(%rsi), %rsi
cmpb $0x1c, (%rsi)
je 0xc5053
movq 0x10(%rdx), %rdx
cmpb $0x20, (%rdx)
je 0xc5037
xorl %edi, %edi
jmp 0xc503b
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testb $0x40, 0x7(%r15)
jne 0xc50a3
addq $-0x20, 0x50(%rbx)
jmp 0xc50b2
andb $-0x5, 0x1(%r15)
movl $0x0, 0x2138(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opaq
static s7_pointer fx_c_opaq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    p = cadr(arg);
                    set_car(sc->t1_1, fx_call(sc, cdr(p)));
                    set_car(sc->t1_1, c_call(p)(sc, sc->t1_1));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x568(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x568(%r14), %rsi
movq %r14, %rdi
callq *0x20(%r15)
movq 0x568(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x568(%r14), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opaaaq
static s7_pointer fx_c_opaaaq(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer arg;
                    arg = cadr(code);
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    gc_protect_direct(sc, fx_call(sc, cdr(arg)));
                    sc->stack_end[-4] = fx_call(sc, cddr(arg));
                    set_car(sc->t3_3, fx_call(sc, cdddr(arg)));
                    set_car(sc->t3_1, sc->stack_end[-2]);
                    set_car(sc->t3_2, sc->stack_end[-4]);
                    sc->stack_end -= 4;
                    set_car(sc->t1_1, c_call(arg)(sc, sc->t3_1));
                    return(c_call(code)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, -0x20(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x20(%rax), %rax
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
movq 0x580(%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_c_s_opaq
static s7_pointer fx_c_s_opaq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer arg2;
                    arg2 = cdaddr(arg);
                    set_car(sc->t1_1, fx_call(sc, arg2));
                    set_car(sc->t2_2, c_call(caddr(arg))(sc, sc->t1_1));
                    set_car(sc->t2_1, lookup_checked(sc, cadr(arg)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rdx
movq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0xc528d
jle 0xc5288
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jl 0xc527b
cmpq %rax, %rdx
jne 0xc52c4
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xc52a2
movq %rbx, %rdi
callq 0xa2ee9
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xc52f2
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %dl
je 0xc52e5
cmpq %rsi, 0x8(%rdi)
je 0xc52e1
movq 0x18(%rdi), %rdi
jmp 0xc52cd
movq 0x10(%rdi), %rax
testb %dl, %dl
je 0xc5295
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xc52c9
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xc5291
xorl %eax, %eax
jmp 0xc5295
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opaq_s
static s7_pointer fx_c_opaq_s(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer arg2;
                    arg2 = cdadr(arg);
                    set_car(sc->t1_1, fx_call(sc, arg2));
                    set_car(sc->t2_1, c_call(cadr(arg))(sc, sc->t1_1));
                    set_car(sc->t2_2, lookup_checked(sc, caddr(arg)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rdx
movq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0xc5378
jle 0xc5373
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jl 0xc5366
cmpq %rax, %rdx
jne 0xc53af
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xc538d
movq %rbx, %rdi
callq 0xa2ee9
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xc53dd
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %dl
je 0xc53d0
cmpq %rsi, 0x8(%rdi)
je 0xc53cc
movq 0x18(%rdi), %rdi
jmp 0xc53b8
movq 0x10(%rdi), %rax
testb %dl, %dl
je 0xc5380
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xc53b4
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xc537c
xorl %eax, %eax
jmp 0xc5380
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_s_opaaq
static s7_pointer fx_c_s_opaaq(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer arg;
                    arg = caddr(code);
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    gc_protect_direct(sc, fx_call(sc, cdr(arg)));
                    set_car(sc->t2_2, fx_call(sc, cddr(arg)));
                    set_car(sc->t2_1, sc->stack_end[-2]);
                    set_car(sc->t2_2, c_call(arg)(sc, sc->t2_1));
                    set_car(sc->t2_1, lookup(sc, cadr(code)));
                    sc->stack_end -= 4;
                    return(c_call(code)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r15), %rax
movq 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)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xc549e
jle 0xc5499
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xc548c
cmpq %rdx, %rsi
jne 0xc54cb
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x570(%rbx), %rax
movq %rdx, 0x8(%rax)
addq $-0x20, 0x50(%rbx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xc54fb
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %sil
je 0xc54ed
cmpq %rax, 0x8(%rdi)
je 0xc54e9
movq 0x18(%rdi), %rdi
jmp 0xc54d4
movq 0x10(%rdi), %rdx
testb %sil, %sil
je 0xc54a6
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xc54d0
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xc54a2
xorl %edx, %edx
jmp 0xc54a6