LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: p_fx_any_ok
static bool p_fx_any_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer x)
                {
                    s7_function f;
                    if (has_fx(x))
                        f = c_callee(x);
                    else f = fx_choose(sc, x, sc->envir, let_symbol_is_safe);
                    if (f)
                    {
                        opc->v[0].fp = opt_p_fx_any;
                        opc->v[1].call = f;
                        opc->v[2].p = car(x);
                        return(oo_set_type_0(opc, 3));
                    }
                    return(return_false(sc, x, __func__, __LINE__));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
testb $0x4, 0x6(%rdx)
jne 0xa566a
movq 0x8(%rdi), %rdx
leaq 0xbaf5(%rip), %rcx      # 0xb1155
movq %r14, %rsi
callq 0xaf535
jmp 0xa566e
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xa5691
leaq 0xbb59(%rip), %rcx      # 0xb11d3
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq $0x3, 0x60(%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_cell_quote
static bool opt_cell_quote(s7_scheme *sc, s7_pointer car_x)
                {
                    opt_info *opc;
                    if (!is_null(cddr(car_x)))
                        return(return_false(sc, car_x, __func__, __LINE__));
                    opc = alloc_opo(sc, car_x);
                    opc->v[1].p = cadr(car_x);
                    opc->v[0].fp = opt_p_c;
                    return(oo_set_type_0(opc, 2));
                }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x110(%rdi), %rcx
cmpq %rcx, %rax
jne 0xa576b
movslq 0x2258(%rdi), %rdx
cmpq $0x100, %rdx            # imm = 0x100
jge 0xa5772
leal 0x1(%rdx), %r8d
movl %r8d, 0x2258(%rdi)
movq 0x2260(%rdi,%rdx,8), %rdx
movq $0x0, 0x38(%rdx)
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rdx)
leaq -0xc1(%rip), %rsi       # 0xa569f
movq %rsi, (%rdx)
movq $0x2, 0x60(%rdx)
cmpq %rcx, %rax
sete %al
retq
pushq %rax
addq $0x2190, %rdi           # imm = 0x2190
movl $0x1, %esi
callq 0x8530
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_cell_begin
static bool opt_cell_begin(s7_scheme *sc, s7_pointer car_x, int32_t len)
                {
                    opt_info *opc;
                    s7_pointer p;
                    opc = alloc_opo(sc, car_x);
                    for (p = cdr(car_x); is_pair(p); p = cdr(p))
                    {
                        opt_info *start;
                        start = sc->opts[sc->pc];
                        if (!cell_optimize(sc, p))
                            return(return_false(sc, car_x, __func__, __LINE__));
                        if (is_pair(cdr(p)))
                            oo_idp_nr_fixup(start);
                    }
                    opc->v[1].i = len - 1;
                    opc->v[0].fp = (len == 3) ? opt_begin_p_1 : opt_begin_p;
                    return(oo_set_type_0(opc, 2));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movslq 0x2258(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0xa6654
movl %edx, %ebx
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
movq 0x2260(%r14,%rax,8), %r13
movq $0x0, 0x38(%r13)
movq 0x10(%rsi), %r15
cmpb $0x1, (%r15)
jne 0xa661c
movslq 0x2258(%r14), %rax
movq 0x2260(%r14,%rax,8), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2000
testb %al, %al
je 0xa6650
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0xa661c
movq %r12, %rdi
callq 0xa98e2
movq 0x10(%r15), %r15
jmp 0xa65e1
cmpl $0x3, %ebx
leaq 0x334a(%rip), %rax      # 0xa9970
leaq 0x337f(%rip), %rcx      # 0xa99ac
cmoveq %rax, %rcx
leal -0x1(%rbx), %eax
movq %rax, 0x8(%r13)
movq %rcx, (%r13)
movq $0x2, 0x60(%r13)
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0xa6646
addq $0x2190, %r14           # imm = 0x2190
movq %r14, %rdi
movl $0x1, %esi
callq 0x8530
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_cell_when
static bool opt_cell_when(s7_scheme *sc, s7_pointer car_x, int32_t len)
                {
                    s7_pointer p;
                    opt_info *opc;
                    opc = alloc_opo(sc, car_x);
                    if (!bool_optimize(sc, cdr(car_x)))
                        return(return_false(sc, car_x, __func__, __LINE__));
                    for (p = cddr(car_x); is_pair(p); p = cdr(p))
                    {
                        opt_info *start;
                        start = sc->opts[sc->pc];
                        if (!cell_optimize(sc, p))
                            return(return_false(sc, car_x, __func__, __LINE__));
                        if (is_pair(cdr(p)))
                            oo_idp_nr_fixup(start);
                    }
                    opc->v[1].i = len - 2;
                    opc->v[3].i = sc->pc - 1;
                    opc->v[0].fp = ((car(car_x) == sc->when_symbol) ? opt_when_p : opt_unless_p);
                    return(oo_set_type_0(opc, 4));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x2258(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0xa6752
movl %edx, %r15d
movq %rsi, %r14
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%rbx)
movq 0x2260(%rbx,%rax,8), %rbp
movq $0x0, 0x38(%rbp)
movq 0x10(%rsi), %rsi
movq %rbx, %rdi
callq 0xa9b3b
testb %al, %al
je 0xa66fe
movq 0x10(%r14), %rax
movq 0x10(%rax), %r12
cmpb $0x1, (%r12)
jne 0xa6702
movslq 0x2258(%rbx), %rax
movq 0x2260(%rbx,%rax,8), %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa2000
testb %al, %al
je 0xa66fe
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0xa6702
movq %r13, %rdi
callq 0xa98e2
movq 0x10(%r12), %r12
jmp 0xa66c0
xorl %eax, %eax
jmp 0xa6743
addl $-0x2, %r15d
movq %r15, 0x8(%rbp)
movslq 0x2258(%rbx), %rax
decq %rax
movq %rax, 0x18(%rbp)
movq 0x8(%r14), %rax
cmpq 0x17f8(%rbx), %rax
leaq 0x348d(%rip), %rax      # 0xa9bb7
leaq 0x3514(%rip), %rcx      # 0xa9c45
cmoveq %rax, %rcx
movq %rcx, (%rbp)
movq $0x4, 0x60(%rbp)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x2190, %rbx           # imm = 0x2190
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8530
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_i_s
static s7_pointer opt_set_p_i_s(opt_info *o)
                {
                    s7_pointer val;
                    oo_rc(o->sc, o, 3, 2);
                    val = slot_value(o->v[2].p);
                    if (is_mutable_integer(val))
                        val = make_integer(o->sc, integer(val));
                    slot_set_value(o->v[1].p, val);
                    return(val);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
testb $0x4, 0x3(%rax)
je 0xa7f96
movq 0x8(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa7f58
leaq 0x9e9fe(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xa7f96
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa7f7c
callq 0xa550
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_i_f
static s7_pointer opt_set_p_i_f(opt_info *o)
                {
                    opt_info *o1;
                    s7_pointer x;
                    oo_rc(o->sc, o, 2, 1);
                    o1 = o->sc->opts[++o->sc->pc];
                    x = make_integer(o->sc, o1->v[0].fi(o1));
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

// 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)
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0xa810f
leaq 0x9e847(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xa814d
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa8133
callq 0xa550
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_d_s
static s7_pointer opt_set_p_d_s(opt_info *o)
                {
                    s7_pointer val;
                    oo_rc(o->sc, o, 3, 2);
                    val = slot_value(o->v[2].p);
                    if (is_mutable_number(val))
                        val = make_real(o->sc, real(val));
                    slot_set_value(o->v[1].p, val);
                    return(val);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
testb $0x4, 0x3(%rax)
je 0xa8359
movsd 0x8(%rax), %xmm0
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa833e
movsd %xmm0, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm0
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: set_p_d_f_combinable
static bool set_p_d_f_combinable(s7_scheme *sc, opt_info *opc)
                {
                    if ((sc->pc > 3) &&
                            (opc == sc->opts[sc->pc - 4]))
                    {
                        opt_info *o1;
                        o1 = sc->opts[sc->pc - 3];
                        if ((o1->v[0].fd == opt_d_mm_fff) &&
                                ((o1->v[3].d_dd_f == add_d_dd) || (o1->v[3].d_dd_f == subtract_d_dd)))
                        {
                            /* opc->v[2].d_dd_f = o1->v[3].d_dd_f; */
                            opc->v[0].fp = (o1->v[3].d_dd_f == add_d_dd) ? opt_set_p_d_f_mm_add : opt_set_p_d_f_mm_subtract;
                            return(true);
                        }
                    }
                    return(return_false(sc, NULL, __func__, __LINE__));
                }

// Assembly:
movl 0x2258(%rdi), %eax
cmpl $0x4, %eax
jl 0xa83d5
leal -0x4(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xa83d5
addl $-0x3, %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq 0x10df(%rip), %rcx      # 0xa9470
cmpq %rcx, (%rax)
jne 0xa83d5
movq 0x18(%rax), %rax
leaq -0x21a8e(%rip), %rcx    # 0x86913
cmpq %rcx, %rax
setne %dl
leaq -0x21a96(%rip), %rdi    # 0x86918
cmpq %rdi, %rax
setne %dil
testb %dil, %dl
jne 0xa83d5
cmpq %rcx, %rax
leaq 0x1161(%rip), %rax      # 0xa9525
leaq 0x1279(%rip), %rcx      # 0xa9644
cmoveq %rax, %rcx
movq %rcx, (%rsi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_d_f
static s7_pointer opt_set_p_d_f(opt_info *o)
                {
                    s7_pointer x;
                    oo_rc(o->sc, o, 6, 1);
                    o->sc->pc++;
                    x = make_real(o->sc, o->v[5].fd(o->v[4].o1));
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rax
incl 0x2258(%rax)
movq 0x20(%rdi), %rdi
callq *0x28(%rbx)
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa8421
movsd %xmm0, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm0
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: is_some_number
static bool is_some_number(s7_scheme *sc, s7_pointer tp)
                {
                    return((tp == sc->is_integer_symbol) ||
                            (tp == sc->is_float_symbol) ||
                            (tp == sc->is_real_symbol) ||
                            (tp == sc->is_complex_symbol) ||
                            (tp == sc->is_number_symbol) ||
                            (tp == sc->is_rational_symbol));
                }

// Assembly:
movb $0x1, %al
cmpq %rsi, 0x10d0(%rdi)
je 0xa86ff
cmpq %rsi, 0x11e0(%rdi)
je 0xa86ff
cmpq %rsi, 0x1180(%rdi)
je 0xa86ff
cmpq %rsi, 0x1038(%rdi)
je 0xa86ff
cmpq %rsi, 0x1120(%rdi)
je 0xa86ff
cmpq %rsi, 0x1178(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_set_p_pip_direct
static s7_pointer typed_vector_set_p_pip_direct(s7_scheme *sc, s7_pointer v, s7_int i, s7_pointer p)
                {
                    if ((i >= 0) && (i < vector_length(v)))
                        typed_vector_setter(sc, v, i, p);
                    else out_of_range(sc, sc->vector_set_symbol, small_int(2), wrap_integer1(sc, i), (i < 0) ? its_negative_string : its_too_large_string);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
testq %rdx, %rdx
js 0xa877a
movq %rsi, %r12
cmpq %r15, 0x8(%rsi)
jle 0xa877a
cmpq $0x0, 0x6a0(%r14)
js 0xa8818
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0xa87f5
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0xa880f
movq 0x1668(%r14), %rax
movq 0x8(%rax), %rax
movq 0x9e1d4(%rip), %rcx     # 0x146960
movq 0x1f00(%r14), %rdx
movq %r15, 0x8(%rdx)
movq 0x1ee8(%r14), %rdx
testq %r15, %r15
leaq 0xa22a0(%rip), %rsi     # 0x14aa48
leaq 0xa2291(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%r14), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%r14), %rsi
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
callq 0x38dfa
jmp 0xa8871
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xaee6
cmpq 0x120(%r14), %rax
je 0xa8823
movq 0x10(%r12), %rax
movq %rbx, (%rax,%r15,8)
jmp 0xa8871
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0xa8833
movq 0x8(%rsi), %rax
jmp 0xa8847
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0x99caa
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x99bbf
leaq 0x6a2fa(%rip), %rsi     # 0x112b58
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
callq 0xd4e5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_set_p_piip_direct
static s7_pointer typed_vector_set_p_piip_direct(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_pointer p)
                {
                    if ((i1 < 0) || (i2 < 0) ||
                            (i1 >= vector_dimension(v, 0)) ||
                            (i2 >= vector_dimension(v, 1)))
                        return(g_vector_set(sc, set_elist_4(sc, v, make_integer(sc, i1), make_integer(sc, i2), p)));
                    return(typed_vector_setter(sc, v, i2 + (i1 * vector_offset(v, 0)), p));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, %rax
orq %rdx, %rax
js 0xa88fb
movq 0x18(%r15), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %r13, (%rcx)
jle 0xa88fb
cmpq %r12, 0x8(%rcx)
jle 0xa88fb
movq 0x18(%rax), %rax
imulq (%rax), %r13
cmpq $0x0, 0x6a0(%r14)
js 0xa8a08
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0xa89df
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %r8, %rbx
movq %r8, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0xa89fc
leaq 0x9e04e(%rip), %rbx     # 0x146950
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0xa8911
movq (%rbx,%r13,8), %rbp
jmp 0xa8951
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xa8936
movq %r14, %rdi
movq %r8, %rbp
callq 0xa550
movq %rbp, %r8
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbp
movq $0xb, (%rbp)
movq %r13, 0x8(%rbp)
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0xa8960
movq (%rbx,%r12,8), %rax
jmp 0xa899f
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xa8985
movq %r14, %rdi
movq %r8, %rbx
callq 0xa550
movq %rbx, %r8
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r12, 0x8(%rax)
movq 0x6f0(%r14), %rcx
movq %r15, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rbp, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %r8, 0x8(%rax)
movq 0x6f0(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x79cc5
movq 0x700(%r14), %rax
movq %r8, %rbx
movq %r8, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xaee6
cmpq 0x120(%r14), %rax
movq %rbx, %r8
je 0xa8a27
shlq $0x3, %r13
addq 0x10(%r15), %r13
movq %r8, (%r13,%r12,8)
movq %r8, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rbx
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0xa8a39
movq 0x8(%rsi), %rax
jmp 0xa8a4d
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0x99caa
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x99bbf
leaq 0x6a0f4(%rip), %rsi     # 0x112b58
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4e5
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_set_p_piip_direct
static s7_pointer vector_set_p_piip_direct(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_pointer p)
                {
                    /* normal untyped vector, rank == 2 */
                    if ((i1 < 0) || (i2 < 0) ||
                            (i1 >= vector_dimension(v, 0)) ||
                            (i2 >= vector_dimension(v, 1)))
                        return(g_vector_set(sc, set_elist_4(sc, v, make_integer(sc, i1), make_integer(sc, i2), p)));
                    vector_element(v, i2 + (i1 * vector_offset(v, 0))) = p;
                    return(p);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rax
orq %rdx, %rax
js 0xa8ae4
movq 0x18(%r14), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %r13, (%rcx)
jle 0xa8ae4
cmpq %r12, 0x8(%rcx)
jle 0xa8ae4
movq 0x18(%rax), %rax
imulq (%rax), %r13
shlq $0x3, %r13
addq 0x10(%r14), %r13
movq %rbx, (%r13,%r12,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9de65(%rip), %rdx     # 0x146950
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0xa8afa
movq (%rdx,%r13,8), %rbp
jmp 0xa8b3a
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0xa8b1f
movq %r15, %rdi
movq %rdx, %rbp
callq 0xa550
movq %rbp, %rdx
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rbp
movq $0xb, (%rbp)
movq %r13, 0x8(%rbp)
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0xa8b49
movq (%rdx,%r12,8), %rax
jmp 0xa8b82
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0xa8b68
movq %r15, %rdi
callq 0xa550
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r12, 0x8(%rax)
movq 0x6f0(%r15), %rcx
movq %r14, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rbp, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rbx, 0x8(%rax)
movq 0x6f0(%r15), %rsi
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x79cc5
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_i_fo_add
static s7_pointer opt_set_p_i_fo_add(opt_info *o)
                {
                    s7_pointer x;
                    s7_int i;
                    oo_rc(o->sc, o, 4, 3);
                    i = integer(slot_value(o->v[2].p)) + integer(slot_value(o->v[3].p));
                    x = make_integer(o->sc, i);
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x10(%rax), %rax
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %r14
addq 0x8(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa9230
leaq 0x9d726(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xa926e
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa9254
callq 0xa550
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_i_fo
static s7_pointer opt_set_p_i_fo(opt_info *o)
                {
                    s7_pointer x;
                    s7_int i;
                    oo_rc(o->sc, o, 4, 3);
                    i = o->v[4].i_ii_f(integer(slot_value(o->v[2].p)), integer(slot_value(o->v[3].p)));
                    x = make_integer(o->sc, i);
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rbx)
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0xa92b8
leaq 0x9d69e(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xa92f6
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa92dc
callq 0xa550
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_i_fo1_add
static s7_pointer opt_set_p_i_fo1_add(opt_info *o)
                {
                    s7_pointer x;
                    s7_int i;
                    oo_rc(o->sc, o, 4, 2);
                    i = integer(slot_value(o->v[2].p)) + o->v[3].i;
                    x = make_integer(o->sc, i);
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r14
movq 0x10(%rax), %rax
addq 0x8(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xa935a
leaq 0x9d5fc(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xa9398
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa937e
callq 0xa550
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_i_fo1
static s7_pointer opt_set_p_i_fo1(opt_info *o)
                {
                    s7_pointer x;
                    s7_int i;
                    oo_rc(o->sc, o, 4, 2);
                    i = o->v[4].i_ii_f(integer(slot_value(o->v[2].p)), o->v[3].i);
                    x = make_integer(o->sc, i);
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq *0x20(%rbx)
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0xa93da
leaq 0x9d57c(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xa9418
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa93fe
callq 0xa550
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: tree_count
static s7_int tree_count(s7_scheme *sc, s7_pointer x, s7_pointer p, s7_int count)
                {
                if (p == x)
                return(count + 1);
                if ((!is_pair(p)) || (car(p) == sc->quote_symbol))
                return(count);
                return(tree_count(sc, x, cdr(p), tree_count(sc, x, car(p), count)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rax
cmpq %rsi, %rdx
je 0xa9467
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, (%rbx)
jne 0xa946a
movq 0x8(%rbx), %rdx
cmpq 0x17b0(%r15), %rdx
je 0xa946a
movq 0x10(%rbx), %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0xa9428
cmpq %r14, %rbx
jne 0xa943e
incq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_d_f_mm_add
static s7_pointer opt_set_p_d_f_mm_add(opt_info *o)
                {
                    opt_info *o1, *o2;
                    s7_double x1, x2;
                    oo_rc(o->sc, o, 3, 1); /* local sc is slower in these two functions */

                    o1 = o->sc->opts[o->sc->pc += 2];
                    x1 = float_vector_ref_d_7pi(o->sc, slot_value(o1->v[2].p), integer(slot_value(o1->v[3].p))) * real(slot_value(o1->v[1].p));
                    o2 = o->sc->opts[++o->sc->pc];
                    x2 = float_vector_ref_d_7pi(o->sc, slot_value(o2->v[2].p), integer(slot_value(o2->v[3].p))) * real(slot_value(o2->v[1].p));

                    slot_set_value(o->v[1].p, make_real(o->sc, x1 + x2));
                    return(slot_value(o->v[1].p));
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
movslq 0x2258(%rdi), %rax
leaq 0x2(%rax), %rcx
movl %ecx, 0x2258(%rdi)
movq 0x2270(%rdi,%rax,8), %r14
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x10(%rax), %rsi
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
callq 0x80b91
movsd %xmm0, 0x20(%rsp)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x68(%rbx), %rdi
movslq 0x2258(%rdi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rdi)
movq 0x2268(%rdi,%rax,8), %r14
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x10(%rax), %rsi
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
callq 0x80b91
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm2
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa95fd
movsd %xmm0, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
movsd 0x20(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: oo_idp_nr_fixup
static void oo_idp_nr_fixup(opt_info *start)
                {
                    if (start->v[0].fp == d_to_p)
                    {
                        start->v[0].fp = d_to_p_nr;
                        if (start->v[7].fd == opt_d_7pid_ssf)
                            start->v[0].fp = opt_d_7pid_ssf_nr;
                        else
                        {
                            if (start->v[7].fd == opt_d_7pid_ssfo_fv)
                            {
                                start->v[0].fp = opt_d_7pid_ssfo_fv_nr;
                                if (start->v[6].d_dd_f == add_d_dd)
                                    start->v[0].fp = opt_d_7pid_ssfo_fv_add_nr;
                                else
                                {
                                    if (start->v[6].d_dd_f == subtract_d_dd)
                                        start->v[0].fp = opt_d_7pid_ssfo_fv_sub_nr;
                                }}}}
                    else
                    {
                        if (start->v[0].fp == i_to_p)
                            start->v[0].fp = i_to_p_nr;
                    }
                }

// Assembly:
movq (%rdi), %rax
leaq -0x6018(%rip), %rcx     # 0xa38d4
cmpq %rcx, %rax
je 0xa98fe
leaq -0x5fc8(%rip), %rcx     # 0xa3930
cmpq %rcx, %rax
je 0xa9953
retq
leaq 0xfd(%rip), %rax        # 0xa9a02
movq %rax, (%rdi)
movq 0x38(%rdi), %rax
leaq -0x9da6(%rip), %rcx     # 0x9fb6d
cmpq %rcx, %rax
je 0xa995c
leaq -0x9273(%rip), %rcx     # 0xa06ac
cmpq %rcx, %rax
jne 0xa98fd
leaq 0x13b(%rip), %rax       # 0xa9a66
movq %rax, (%rdi)
movq 0x30(%rdi), %rax
leaq -0x23026(%rip), %rcx    # 0x86913
cmpq %rcx, %rax
je 0xa9967
leaq -0x2302d(%rip), %rcx    # 0x86918
cmpq %rcx, %rax
jne 0xa98fd
leaq 0x1a4(%rip), %rax       # 0xa9af5
jmp 0xa9963
leaq 0x1d9(%rip), %rax       # 0xa9b33
jmp 0xa9963
leaq 0xa7(%rip), %rax        # 0xa9a0a
movq %rax, (%rdi)
retq
leaq 0x149(%rip), %rax       # 0xa9ab7
jmp 0xa9963
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_begin_p
static s7_pointer opt_begin_p(opt_info *o)
                {
                    opt_info *o1;
                    s7_int i, len;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 2, 0);
                    len = o->v[1].i - 1;
                    for (i = 0; i < len; i++)
                    {
                        o1 = sc->opts[++sc->pc];
                        o1->v[0].fp(o1);
                    }
                    o1 = sc->opts[++sc->pc];
                    return(o1->v[0].fp(o1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
movq 0x68(%rdi), %rbx
cmpq $0x2, %r14
jl 0xa99e0
decq %r14
movslq 0x2258(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
decq %r14
jne 0xa99c1
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: bool_optimize
static bool bool_optimize(s7_scheme *sc, s7_pointer expr)
                {
                    int32_t start;
                    opt_info *wrapper;
                    start = sc->pc;
                    if (bool_optimize_nw(sc, expr))
                        return(true);
                    pc_fallback(sc, start);
                    wrapper = sc->opts[start];
                    if (cell_optimize(sc, expr))
                    {
                        if (wrapper->v[7].fp) /* (when (+ i 1) ...) */
                            return(return_false(sc, NULL, __func__, __LINE__));
                        if (oo_size(wrapper) < 8) oo_resize(wrapper, 8);
                        wrapper->v[7].fp = wrapper->v[0].fp;
                        wrapper->v[0].fb = p_to_b;
                        return(true);
                    }
                    return(return_false(sc, NULL, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x2258(%rdi), %ebp
callq 0xa9cd3
movb $0x1, %bl
testb %al, %al
jne 0xa9b85
movslq %ebp, %rax
movl %eax, 0x2258(%r15)
movq 0x2260(%r15,%rax,8), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xa2000
testb %al, %al
je 0xa9b83
cmpq $0x0, 0x38(%r12)
je 0xa9b90
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x7, 0x60(%r12)
jg 0xa9ba1
movl $0x8, 0x60(%r12)
movq (%r12), %rax
movq %rax, 0x38(%r12)
leaq 0x4fa(%rip), %rax       # 0xaa0ab
movq %rax, (%r12)
jmp 0xa9b85
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_when_p
static s7_pointer opt_when_p(opt_info *o)
                {
                    opt_info *o1;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 4, 0);
                    o1 = sc->opts[++sc->pc];
                    if (o1->v[0].fb(o1))
                    {
                        int32_t i, len;
                        len = o->v[1].i - 1;
                        for (i = 0; i < len; i++)
                        {
                            o1 = sc->opts[++sc->pc];
                            o1->v[0].fp(o1);
                        }
                        o1 = sc->opts[++sc->pc];
                        return(o1->v[0].fp(o1));
                    }
                    sc->pc = o->v[3].i;
                    return(sc->unspecified);
                }

// 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)
testb %al, %al
je 0xa9c2c
movl 0x8(%rbx), %ebx
decl %ebx
testl %ebx, %ebx
jle 0xa9c0a
movslq 0x2258(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
decl %ebx
jne 0xa9beb
movslq 0x2258(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rdi)
movl 0x18(%rbx), %eax
movl %eax, 0x2258(%r14)
movq 0x130(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: b_pi_ok
static bool b_pi_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x, s7_pointer arg2)
                {
                    s7_b_pi_t bpif;
                    bpif = s7_b_pi_function(s_func);
                    if (bpif)
                    {
                        opc->v[1].p = symbol_to_slot(sc, arg2); /* slot checked in opt_arg_type */
                        if (cell_optimize(sc, cdr(car_x)))
                        {
                            opc->v[2].b_pi_f = bpif;
                            opc->v[0].fb = opt_b_pi_fs;
                            return(oo_set_type_1(opc, 3, 1, OO_P));
                        }
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0xaa8a5
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xaa917
movq %rsi, %rbx
cmpl $0x20, (%rax)
je 0xaa8a8
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xaa895
jmp 0xaa917
xorl %eax, %eax
retq
movq 0x8(%rax), %r14
testq %r14, %r14
je 0xaa917
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r9
movq 0x20(%r8), %rsi
movl $0x18, %eax
cmpq %rsi, %r9
je 0xaa8db
jle 0xaa8d6
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r9
cmpq %r9, %rsi
jl 0xaa8c9
cmpq %rsi, %r9
jne 0xaa921
movq (%r8,%rax), %rsi
movq %rsi, 0x8(%rbx)
movq 0x10(%rcx), %rsi
callq 0xa2000
testb %al, %al
je 0xaa917
movq %r14, 0x10(%rbx)
leaq 0xfb4(%rip), %rax       # 0xab8af
movq %rax, (%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
movb $0x1, %al
jmp 0xaa919
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %eax
cmpb $0x1c, (%rdx)
jne 0xaa8db
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0xaa940
cmpq %r8, 0x8(%rsi)
je 0xaa8df
movq 0x18(%rsi), %rsi
jmp 0xaa92f
movq 0x10(%rdx), %rdx
jmp 0xaa926
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_and_any_b
static bool opt_and_any_b(opt_info *o)
                {
                    int32_t i;
                    oo_rc(o->sc, o, 3, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        if (!o1->v[0].fb(o1))
                        {
                            o->sc->pc = o->v[2].i;
                            return(false);
                        }
                    }
                    return(true);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movb $0x1, %bl
cmpq $0x0, 0x8(%rdi)
jle 0xab57f
movq %rdi, %r14
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)
testb %al, %al
je 0xab56f
incq %r15
cmpq %r15, 0x8(%r14)
jg 0xab541
jmp 0xab57f
movl 0x10(%r14), %eax
movq 0x68(%r14), %rcx
movl %eax, 0x2258(%rcx)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_or_any_b
static bool opt_or_any_b(opt_info *o)
                {
                    int32_t i;
                    oo_rc(o->sc, o, 3, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        if (o1->v[0].fb(o1))
                        {
                            o->sc->pc = o->v[2].i;
                            return(true);
                        }
                    }
                    return(false);
                }

// Assembly:
cmpq $0x0, 0x8(%rdi)
jle 0xab5c8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
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)
testb %al, %al
jne 0xab5cb
incq %r14
cmpq %r14, 0x8(%rbx)
jg 0xab598
xorl %eax, %eax
jmp 0xab5da
xorl %eax, %eax
retq
movl 0x10(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_cond_clause
static s7_pointer opt_cond_clause(opt_info *o)
                {
                    /* top->p1 gets result, top->i1 is end index, o->v[3].i is end of current clause, o->v[1].i = body len */
                    opt_info *o1;
                    o1 = o->sc->opts[++o->sc->pc];
                    if (o1->v[0].fb(o1))
                        return(case_value(o));
                    o->sc->pc = o->v[3].i;
                    return(o->sc->unspecified);
                }

// Assembly:
pushq %rbx
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)
testb %al, %al
je 0xabdae
movq %rbx, %rdi
popq %rbx
jmp 0xabea7
movl 0x18(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_cond
static s7_pointer opt_cond(opt_info *o)
                {
                    oo_rc(o->sc, o, 3, 0);
                    o->v[2].p = o->sc->unspecified;
                    while (o->sc->pc < o->v[1].i)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        o1->v[0].fp(o1);
                    }
                    return(o->v[2].p);
                }

// Assembly:
movq 0x8(%rdi), %rsi
movq 0x68(%rdi), %rcx
movq 0x130(%rcx), %rax
movq %rax, 0x10(%rdi)
movslq 0x2258(%rcx), %rdx
cmpq %rdx, %rsi
jle 0xabe13
pushq %rbx
movq %rdi, %rbx
leal 0x1(%rdx), %eax
movl %eax, 0x2258(%rcx)
movslq %edx, %rax
movq 0x2268(%rcx,%rax,8), %rdi
callq *(%rdi)
movq 0x68(%rbx), %rcx
movslq 0x2258(%rcx), %rdx
cmpq %rdx, 0x8(%rbx)
jg 0xabde7
movq 0x10(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_cond_2
static s7_pointer opt_cond_2(opt_info *o)
                {
                    /* 2 branches, results 1 expr, else */
                    opt_info *o1, *o2;
                    s7_pointer res;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 2, 0);
                    sc->pc += 2;
                    o2 = sc->opts[sc->pc];           /* this is the boolean expr of the first clause */
                    if (!o2->v[0].fb(o2))
                        sc->pc = o->v[3].i;            /* jump over first clause and #t */
                    o1 = sc->opts[++sc->pc];
                    res = o1->v[0].fp(o1);
                    sc->pc = o->v[1].i;              /* end of cond index */
                    return(res);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x2(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2270(%r14,%rax,8), %rdi
callq *(%rdi)
testb %al, %al
je 0xabe7c
movl 0x2258(%r14), %eax
jmp 0xabe7f
movl 0x18(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
cltq
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movl 0x8(%rbx), %ecx
movl %ecx, 0x2258(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: case_value
static s7_pointer case_value(opt_info *o)
                {
                    opt_info *top, *o1;
                    int32_t i, len;
                    s7_scheme *sc;
                    sc = o->sc;
                    top = (opt_info *)(o->v[5].obj);
                    len = o->v[1].i - 1;
                    for (i = 0; i < len; i++)
                    {
                        o1 = sc->opts[++sc->pc];
                        o1->v[0].fp(o1);
                    }
                    o1 = sc->opts[++sc->pc];
                    top->v[2].p = o1->v[0].fp(o1);
                    sc->pc = top->v[1].i;
                    return(top->v[2].p);
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x68(%rdi), %rbx
movq 0x28(%rdi), %r14
movl 0x8(%rdi), %ebp
decl %ebp
testl %ebp, %ebp
jle 0xabeda
movslq 0x2258(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
decl %ebp
jne 0xabebc
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq %rax, 0x10(%r14)
movl 0x8(%r14), %eax
movl %eax, 0x2258(%rbx)
movq 0x10(%r14), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_or_any_p
static s7_pointer opt_or_any_p(opt_info *o)
                {
                    int32_t i;
                    oo_rc(o->sc, o, 3, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        s7_pointer val;
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        val = o1->v[0].fp(o1);
                        if (val != o->sc->F)
                        {
                            o->sc->pc = o->v[2].i;
                            return(val);
                        }
                    }
                    return(o->sc->F);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
movq 0x68(%rdi), %rdx
jle 0xac028
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x2258(%rdx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rdx)
movq 0x2268(%rdx,%rax,8), %rdi
callq *(%rdi)
movq %rax, %rcx
movq 0x68(%rbx), %rdx
movq 0x120(%rdx), %rax
cmpq %rax, %rcx
jne 0xac031
incq %r14
cmpq %r14, 0x8(%rbx)
jg 0xabfef
jmp 0xac03d
movq 0x120(%rdx), %rax
jmp 0xac03d
movl 0x10(%rbx), %eax
movl %eax, 0x2258(%rdx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_and_any_p
static s7_pointer opt_and_any_p(opt_info *o)
                {
                    int32_t i;
                    s7_pointer val;
                    oo_rc(o->sc, o, 3, 0);
                    val = o->sc->T; /* (and) -> #t */
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        val = o1->v[0].fp(o1);
                        if (val == o->sc->F)
                        {
                            o->sc->pc = o->v[2].i;
                            return(o->sc->F);
                        }
                    }
                    return(val);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rdx
cmpq $0x0, 0x8(%rdi)
jle 0xac093
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x2258(%rdx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rdx)
movq 0x2268(%rdx,%rax,8), %rdi
callq *(%rdi)
movq 0x68(%rbx), %rdx
movq 0x120(%rdx), %rcx
cmpq %rcx, %rax
je 0xac09c
incq %r14
cmpq %r14, 0x8(%rbx)
jg 0xac05a
movq %rax, %rcx
jmp 0xac0a5
movq 0x118(%rdx), %rcx
jmp 0xac0a5
movl 0x10(%rbx), %eax
movl %eax, 0x2258(%rdx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_7sc
static s7_pointer opt_if_nbp_7sc(opt_info *o) /* b_7pp_sc */
                {
                    oo_rc(o->sc, o, 4, 1);
                    if (!(o->v[3].b_7pp_f(o->sc, slot_value(o->v[2].p), o->v[4].p)))
                    {
                        opt_info *o1;
                        o->sc->pc += 2;
                        o1 = o->sc->opts[o->sc->pc];
                        return(o1->v[0].fp(o1));
                    }
                    o->sc->pc = o->v[1].i;
                    return(o->sc->unspecified);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rdx
movq 0x10(%rax), %rsi
callq *0x18(%rbx)
testb %al, %al
je 0xac3dc
movl 0x8(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
popq %rbx
retq
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x2(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2270(%rax,%rcx,8), %rdi
popq %rbx
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_case_clause
static s7_pointer opt_case_clause(opt_info *o)
                {
                    /* top->v[2].p gets result, top->i1 is end index, top->v[4].p is selector, o->v[3].i is end of current clause, o->v[1].i = body len */
                    opt_info *top;
                    oo_rc(o->sc, o, 6, 0);
                    top = (opt_info *)(o->v[5].obj);
                    if ((o->v[2].p == o->sc->else_symbol) ||
                            (case_memv(o->sc, top->v[4].p, o->v[2].p)))
                        return(case_value(o));
                    o->sc->pc = o->v[3].i;
                    return(o->sc->unspecified);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movq 0x68(%rdi), %r15
cmpq 0x1790(%r15), %r12
je 0xac6f1
movq 0x28(%rbx), %rax
movq 0x20(%rax), %r14
movzbl (%r14), %ecx
leaq 0xa6a10(%rip), %rdx     # 0x1530a0
movb (%r12), %al
cmpb $0x0, (%rcx,%rdx)
je 0xac6b3
cmpb $0x1, %al
jne 0xac6d4
cmpq %r14, 0x8(%r12)
je 0xac6f1
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xac69e
jmp 0xac6d4
cmpb $0x1, %al
jne 0xac6d4
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x40412
testb %al, %al
jne 0xac6f1
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xac6b7
movl 0x18(%rbx), %eax
movl %eax, 0x2258(%r15)
movq 0x130(%r15), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xabea7