LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_s
static s7_pointer opt_if_nbp_s(opt_info *o)
                {
                    oo_rc(o->sc, o, 4, 1);
                    if (!(o->v[2].b_p_f(slot_value(o->v[3].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 0x18(%rdi), %rax
movq 0x10(%rax), %rdi
callq *0x10(%rbx)
testb %al, %al
je 0xb3187
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_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_fs
static s7_pointer opt_if_nbp_fs(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 4, 1);
                    o->sc->pc += 2;
                    o1 = o->sc->opts[o->sc->pc];
                    if (!(o->v[2].b_pi_f(o->sc, o1->v[0].fp(o1), integer(slot_value(o->v[3].p))))) /* b_pi_fs */
                    {
                        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 %r15
pushq %r14
pushq %rbx
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
movq 0x10(%rbx), %r15
callq *(%rdi)
movq 0x18(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq *%r15
testb %al, %al
je 0xb3206
movl 0x8(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_sf
static s7_pointer opt_if_nbp_sf(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 4, 1);
                    o->sc->pc += 2;
                    o1 = o->sc->opts[o->sc->pc];
                    if (!(o->v[2].b_pp_f(slot_value(o->v[3].p), o1->v[0].fp(o1))))   /* b_pp_sf */
                    {
                        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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
leaq 0x2(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2270(%rax,%rcx,8), %rdi
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rax
movq 0x10(%rax), %r14
callq *(%rdi)
movq %r14, %rdi
movq %rax, %rsi
callq *%r15
testb %al, %al
je 0xb3284
movl 0x8(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_7sf
static s7_pointer opt_if_nbp_7sf(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 4, 1);
                    o->sc->pc += 2;
                    o1 = o->sc->opts[o->sc->pc];
                    if (!(o->v[2].b_7pp_f(o->sc, slot_value(o->v[3].p), o1->v[0].fp(o1))))   /* b_7pp_sf */
                    {
                        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 %r15
pushq %r14
pushq %r12
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
movq 0x10(%rbx), %r12
movq 0x18(%rbx), %rax
movq 0x10(%rax), %r15
callq *(%rdi)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq *%r12
testb %al, %al
je 0xb330f
movl 0x8(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_sc
static s7_pointer opt_if_nbp_sc(opt_info *o) /* b_pp_sc */
                {
                    oo_rc(o->sc, o, 4, 1);
                    if (!(o->v[3].b_pp_f(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 0x10(%rdi), %rax
movq 0x20(%rdi), %rsi
movq 0x10(%rax), %rdi
callq *0x18(%rbx)
testb %al, %al
je 0xb3366
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_O1/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 0xb33b7
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_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_ss
static s7_pointer opt_if_nbp_ss(opt_info *o) /* b_ii_ss */
                {
                    oo_rc(o->sc, o, 4, 2);
                    if (!(o->v[3].b_ii_f(integer(slot_value(o->v[2].p)), integer(slot_value(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 0x10(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rsi
callq *0x18(%rbx)
testb %al, %al
je 0xb3410
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_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_bp
static s7_pointer opt_if_bp(opt_info *o)
                {
                    oo_rc(o->sc, o, 6, 0);
                    o->sc->pc++;
                    if (o->v[3].fb(o->v[2].o1))
                    {
                        o->sc->pc++;
                        return(o->v[5].fp(o->v[4].o1));
                    }
                    o->sc->pc = o->v[1].i;
                    return(o->sc->unspecified);
                }

// Assembly:
pushq %rbx
movq %rdi, %rcx
movq 0x68(%rdi), %rax
incl 0x2258(%rax)
movq 0x10(%rdi), %rdi
movq %rcx, %rbx
callq *0x18(%rcx)
testb %al, %al
je 0xb3461
movq %rbx, %rcx
movq 0x68(%rbx), %rax
incl 0x2258(%rax)
movq 0x20(%rbx), %rdi
popq %rbx
jmpq *0x28(%rcx)
movl 0x8(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_bp_pb
static s7_pointer opt_if_bp_pb(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 2, 0);
                    o1 = o->sc->opts[++o->sc->pc];
                    if (o1->v[7].fp(o1) != o->sc->F)
                    {
                        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), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *0x38(%rdi)
movq 0x68(%rbx), %rcx
cmpq 0x120(%rcx), %rax
je 0xb34c4
movslq 0x2258(%rcx), %rax
leaq 0x1(%rax), %rdx
movl %edx, 0x2258(%rcx)
movq 0x2268(%rcx,%rax,8), %rdi
popq %rbx
jmpq *(%rdi)
movl 0x8(%rbx), %eax
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_bp_ii_fc
static s7_pointer opt_if_bp_ii_fc(opt_info *o)
                {
                    opt_info *o1, *o2;
                    oo_rc(o->sc, o, 2, 0);
                    o1 = o->sc->opts[++o->sc->pc];
                    o2 = o->sc->opts[++o->sc->pc];
                    if (o1->v[3].b_ii_f(o2->v[0].fi(o2), o1->v[2].i))
                        /* if (o1->v[7].fp(o1) != o->sc->F) */
                    {
                        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 %r15
pushq %r14
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), %r14
leaq 0x2(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2270(%rax,%rcx,8), %rdi
movq 0x18(%r14), %r15
callq *(%rdi)
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq *%r15
testb %al, %al
je 0xb35bb
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *(%rdi)
movl 0x8(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_bpp
static s7_pointer opt_if_bpp(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 4, 0);
                    o1 = o->sc->opts[++o->sc->pc];
                    if (o1->v[0].fb(o1))
                    {
                        s7_pointer val;
                        o1 = o->sc->opts[++o->sc->pc];
                        val = o1->v[0].fp(o1);
                        o->sc->pc = o->v[3].i;
                        return(val);
                    }
                    o->sc->pc = o->v[1].i;
                    o1 = o->sc->opts[++o->sc->pc];
                    return(o1->v[0].fp(o1));
                }

// 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 0xb362a
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movl 0x18(%rbx), %ecx
movq 0x68(%rbx), %rdx
movl %ecx, 0x2258(%rdx)
popq %rbx
retq
movslq 0x8(%rbx), %rax
movq 0x68(%rbx), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x2258(%rcx)
movq 0x2268(%rcx,%rax,8), %rdi
popq %rbx
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O1/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 0xb36c0
movq 0x28(%rbx), %rax
movq 0x20(%rax), %r14
movzbl (%r14), %ecx
leaq 0xa7a2b(%rip), %rdx     # 0x15b0a0
movb (%r12), %al
cmpb $0x0, (%rcx,%rdx)
je 0xb369b
cmpb $0x1, %al
jne 0xb36d3
cmpq %r14, 0x8(%r12)
sete %al
je 0xb36bc
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xb3683
jmp 0xb36d3
cmpb $0x1, %al
jne 0xb36d3
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x42c67
testb %al, %al
jne 0xb36bc
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xb369f
testb %al, %al
je 0xb36d3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb2e75
movl 0x18(%rbx), %eax
movl %eax, 0x2258(%r15)
movq 0x130(%r15), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_case
static s7_pointer opt_case(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 5, 0);
                    o->v[2].p = o->sc->unspecified;
                    o1 = o->sc->opts[++o->sc->pc];
                    o->v[4].p = o1->v[0].fp(o1);
                    while (o->sc->pc < o->v[1].i)
                    {
                        o1 = o->sc->opts[++o->sc->pc];
                        o1->v[0].fp(o1);
                    }
                    return(o->v[2].p);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movq 0x130(%rax), %rcx
movq %rcx, 0x10(%rdi)
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movq %rax, 0x20(%rbx)
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
cmpq %rcx, 0x8(%rbx)
jle 0xb374b
leal 0x1(%rcx), %edx
movl %edx, 0x2258(%rax)
movslq %ecx, %rcx
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
jmp 0xb3722
movq 0x10(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_let_temporarily
static s7_pointer opt_let_temporarily(opt_info *o)
                {
                    opt_info *o1;
                    int32_t i, len;
                    s7_pointer result;
#if S7_DEBUGGING
                    if (cur_sc->stack_end >= cur_sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    oo_rc(o->sc, o, 5, 1);
                    o1 = o->sc->opts[++o->sc->pc];
                    o->v[4].p = slot_value(o->v[1].p);         /* save and protect old value */
                    gc_protect_direct(o->sc, o->v[4].p);

                    if (is_immutable_slot(o->v[1].p))
                        immutable_object_error(o->sc, set_elist_3(o->sc, immutable_error_string, o->sc->let_temporarily_symbol, slot_symbol(o->v[1].p)));
                    slot_set_value(o->v[1].p, o1->v[0].fp(o1)); /* set new value */

                    len = o->v[2].i - 1;
                    for (i = 0; i < len; i++)
                    {
                        o1 = o->sc->opts[++o->sc->pc];
                        o1->v[0].fp(o1);
                    }
                    o1 = o->sc->opts[++o->sc->pc];
                    result = o1->v[0].fp(o1);

                    slot_set_value(o->v[1].p, o->v[4].p);      /* restore old */
                    o->sc->stack_end -= 4;

                    return(result);
                }

// Assembly:
pushq %rbp
pushq %r14
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), %r14
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x20(%rdi)
movq 0x50(%rax), %rdx
movq $0x1, 0x18(%rdx)
movq 0x50(%rax), %rdx
leaq 0x20(%rdx), %rsi
movq %rsi, 0x50(%rax)
movq %rcx, 0x10(%rdx)
movq 0x8(%rdi), %rax
testb $0x1, 0x3(%rax)
je 0xb37eb
movq 0x68(%rbx), %rdi
movq 0x9f1b6(%rip), %rcx     # 0x152968
movq 0x1248(%rdi), %rdx
movq 0x8(%rax), %rax
movq 0x6e8(%rdi), %rsi
movq %rcx, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e8(%rdi), %rdx
movq 0xea8(%rdi), %rsi
callq 0x3b366
movq %r14, %rdi
callq *(%r14)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movl 0x10(%rbx), %ebp
decl %ebp
testl %ebp, %ebp
jle 0xb3825
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
decl %ebp
jne 0xb3802
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movq 0x8(%rbx), %rcx
movq 0x20(%rbx), %rdx
movq %rdx, 0x10(%rcx)
movq 0x68(%rbx), %rcx
addq $-0x20, 0x50(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: stop_is_safe
static bool stop_is_safe(s7_scheme *sc, s7_pointer stop, s7_pointer body)
                {
                    /* this could be folded into the cell_optimize traveral */
                    s7_pointer p;
                    for (p = body; is_pair(p); p = cdr(p))
                        if ((is_pair(car(p))) &&
                                (caar(p) == sc->set_symbol) &&
                                (is_pair(cdar(p))) &&
                                (cadar(p) == stop))
                            return(!s7_tree_memq(sc, stop, cdr(p)));
                    return(true);
                }

// Assembly:
movb $0x1, %al
cmpb $0x1, (%rdx)
jne 0xb3898
pushq %rax
movq 0x8(%rdx), %rcx
cmpb $0x1, (%rcx)
jne 0xb388b
movq 0x8(%rcx), %r8
cmpq 0x18d8(%rdi), %r8
jne 0xb388b
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xb388b
cmpq %rsi, 0x8(%rcx)
je 0xb3899
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
je 0xb3866
addq $0x8, %rsp
retq
movq 0x10(%rdx), %rdx
callq 0x3b26e
xorb $0x1, %al
jmp 0xb3894
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_do_no_vars
static s7_pointer opt_do_no_vars(opt_info *o)
                {
                    /* no vars, no return, o->v[2].p=frame, o->v[1].i=body end index, o->v[3].i=body length, o->v[4].i=return length, o->v[5].i=end index */
                    opt_info *ostart;
                    int32_t loop, len;
                    s7_pointer old_e;
                    s7_scheme *sc;
                    sc = o->sc;

                    oo_rc(sc, o, 10, 0);
                    old_e = sc->envir;
                    push_stack_no_let_no_code(sc, OP_GC_PROTECT, old_e);
                    sc->envir = o->v[2].p;
                    len = o->v[3].i;

                    loop = ++sc->pc;
                    ostart = sc->opts[loop];
                    if (len == 0)
                    {
                        while (true)
                        {
                            if (ostart->v[0].fb(ostart)) break;
                            sc->pc = loop;
                        }
                    }
                    else
                    {
                        while (true)
                        {
                            int32_t i;
                            if (ostart->v[0].fb(ostart)) break;
                            for (i = 0; i < len; i++)
                            {
                                opt_info *o1;
                                o1 = sc->opts[++sc->pc];
                                o1->v[0].fp(o1);
                            }
                            sc->pc = loop;
                        }
                    }
                    sc->pc = o->v[5].i;
                    unstack(sc);
                    sc->envir = old_e;
                    return(sc->T);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x68(%rdi), %r15
movq 0x8(%r15), %rcx
movq 0x50(%r15), %rax
movq %rcx, 0x10(%rsp)
movq %rcx, 0x10(%rax)
movq 0x50(%r15), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%r15)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%r15)
movq %rdi, 0x8(%rsp)
movl 0x18(%rdi), %ebx
movslq 0x2258(%r15), %rax
leaq 0x1(%rax), %r13
movl %r13d, 0x2258(%r15)
movq 0x2268(%r15,%rax,8), %r14
testl %ebx, %ebx
je 0xb3950
movq %r14, %rdi
callq *(%r14)
testb %al, %al
jne 0xb395a
movl %eax, %ebp
testl %ebx, %ebx
jle 0xb393b
movl %ebx, %r12d
movslq 0x2258(%r15), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r15)
movq 0x2268(%r15,%rax,8), %rdi
callq *(%rdi)
decl %r12d
jne 0xb391b
movl %r13d, 0x2258(%r15)
testb %bpl, %bpl
je 0xb3908
jmp 0xb395a
movl %r13d, 0x2258(%r15)
movq %r14, %rdi
callq *(%r14)
testb %al, %al
je 0xb3949
movq 0x8(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x2258(%r15)
addq $-0x20, 0x50(%r15)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r15)
movq 0x118(%r15), %rax
addq $0x18, %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: opt_do_step_1
static s7_pointer opt_do_step_1(opt_info *o)
                {
                    /* 1 stepper (multi inits perhaps), 1 body, 1 rtn */
                    opt_info *o1, *ostart, *ostep;
                    int32_t loop;
                    s7_pointer vp, old_e, result, stepper = NULL;
                    s7_scheme *sc;

                    sc = o->sc;
                    ostep = o->v[9].o1;
                    old_e = sc->envir;
                    push_stack_no_let_no_code(sc, OP_GC_PROTECT, old_e);
                    sc->envir = T_Let(o->v[2].p);

                    for (vp = let_slots(sc->envir); tis_slot(vp); vp = next_slot(vp))
                    {
                        o1 = sc->opts[++sc->pc];
                        slot_set_value(vp, o1->v[0].fp(o1));
                        if (has_stepper(vp)) stepper = vp;
                    }
                    loop = ++sc->pc;
                    ostart = sc->opts[loop];
                    while (true)
                    {
                        if (ostart->v[0].fb(ostart)) break;
                        o1 = sc->opts[++sc->pc];
                        o1->v[0].fp(o1);
                        sc->pc++;
                        slot_set_value(stepper, ostep->v[0].fp(ostep));
                        sc->pc = loop;
                    }
                    sc->pc = o->v[1].i;
                    o1 = sc->opts[++sc->pc];
                    result = o1->v[0].fp(o1);

                    sc->pc = o->v[5].i;
                    unstack(sc);
                    sc->envir = old_e;
                    return(result);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r14
movq 0x68(%rdi), %r12
movq 0x8(%r12), %rcx
movq 0x50(%r12), %rax
movq %rcx, (%rsp)
movq %rcx, 0x10(%rax)
movq 0x50(%r12), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%r12)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%r12)
movq 0x8(%rax), %r15
xorl %ebp, %ebp
testq %r15, %r15
je 0xb3aa9
movslq 0x2258(%r12), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r12)
movq 0x2268(%r12,%rax,8), %rdi
callq *(%rdi)
movq %rax, 0x10(%r15)
testb $-0x80, 0x2(%r15)
cmovneq %r15, %rbp
movq 0x18(%r15), %r15
jmp 0xb3a74
movslq 0x2258(%r12), %rax
leaq 0x1(%rax), %r13
movl %r13d, 0x2258(%r12)
movq 0x2268(%r12,%rax,8), %r15
movq %r15, %rdi
callq *(%r15)
testb %al, %al
jne 0xb3b08
movslq 0x2258(%r12), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r12)
movq 0x2268(%r12,%rax,8), %rdi
callq *(%rdi)
incl 0x2258(%r12)
movq %r14, %rdi
callq *(%r14)
movq %rax, 0x10(%rbp)
movl %r13d, 0x2258(%r12)
jmp 0xb3ac5
movslq 0x8(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r12)
movq 0x2268(%r12,%rax,8), %rdi
callq *(%rdi)
movl 0x28(%rbx), %ecx
movl %ecx, 0x2258(%r12)
addq $-0x20, 0x50(%r12)
movq (%rsp), %rcx
movq %rcx, 0x8(%r12)
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: opt_do_prepackaged
static s7_pointer opt_do_prepackaged(opt_info *o)
                {
                    opt_info *o1;
                    s7_int end;
                    s7_pointer vp, old_e;
                    s7_scheme *sc;
                    sc = o->sc;

                    oo_rc(sc, o, 10, 0);
                    old_e = sc->envir;
                    push_stack_no_let_no_code(sc, OP_GC_PROTECT, old_e);
                    sc->envir = o->v[2].p;

                    vp = slot_value(let_dox_slot1(o->v[2].p));
                    if (is_slot(let_dox_slot2_unchecked(o->v[2].p)))
                        end = integer(slot_value(let_dox_slot2(o->v[2].p)));
                    else end = o->v[3].i;
                    o1 = sc->opts[++sc->pc];
                    integer(vp) = integer(o1->v[0].fp(o1));

                    o->v[6].p = vp;
                    o->v[1].i = end;
                    o->v[7].fp(o);

                    sc->pc = o->v[5].i;
                    unstack(sc);
                    sc->envir = old_e;
                    return(sc->T);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movq 0x8(%r14), %r15
movq 0x50(%r14), %rax
movq %r15, 0x10(%rax)
movq 0x50(%r14), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%r14)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%r14)
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rcx
movq 0x28(%rax), %rax
movq 0x10(%rcx), %r12
cmpb $0x20, (%rax)
jne 0xb4f1e
movq 0x10(%rax), %rax
addq $0x8, %rax
jmp 0xb4f22
leaq 0x18(%rbx), %rax
movq (%rax), %r13
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x8(%r12)
movq %r12, 0x30(%rbx)
movq %r13, 0x8(%rbx)
movq %rbx, %rdi
callq *0x38(%rbx)
movl 0x28(%rbx), %eax
movl %eax, 0x2258(%r14)
addq $-0x20, 0x50(%r14)
movq %r15, 0x8(%r14)
movq 0x118(%r14), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_do_dpnr
static s7_pointer opt_do_dpnr(opt_info *o)
                {
                    opt_info *o1;
                    int32_t loop;
                    s7_pointer vp;
                    s7_int end;
                    s7_double (*f)(opt_info *o);
                    s7_scheme *sc;
                    sc = o->sc;

                    oo_rc(sc, o, 10, 0);
                    end = o->v[1].i;
                    vp = o->v[6].p;
                    loop = o->v[4].i;
                    o1 = sc->opts[loop]; /* the body */
                    f = o1->v[7].fd;
                    while (integer(vp) < end)
                    {
                        sc->pc = loop;
                        f(o1);
                        integer(vp)++;
                    }
                    return(NULL);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
movq 0x30(%rdi), %r15
cmpq %r14, 0x8(%r15)
jge 0xb4fc9
movq 0x68(%rdi), %r12
movq 0x20(%rdi), %r13
movslq %r13d, %rax
movq 0x2260(%r12,%rax,8), %rbx
movq 0x38(%rbx), %rbp
movl %r13d, 0x2258(%r12)
movq %rbx, %rdi
callq *%rbp
movq 0x8(%r15), %rax
incq %rax
movq %rax, 0x8(%r15)
cmpq %r14, %rax
jl 0xb4fac
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_do_ipnr
static s7_pointer opt_do_ipnr(opt_info *o)
                {
                    opt_info *o1;
                    int32_t loop;
                    s7_pointer vp;
                    s7_int end;
                    s7_int (*f)(opt_info *o);
                    s7_scheme *sc;
                    sc = o->sc;

                    oo_rc(sc, o, 10, 0);
                    end = o->v[1].i;
                    vp = o->v[6].p;
                    loop = o->v[4].i;
                    o1 = sc->opts[loop]; /* the body */
                    f = o1->v[7].fi;
                    while (integer(vp) < end)
                    {
                        sc->pc = loop;
                        f(o1);
                        integer(vp)++;
                    }
                    return(NULL);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
movq 0x30(%rdi), %r15
cmpq %r14, 0x8(%r15)
jge 0xb5027
movq 0x68(%rdi), %r12
movq 0x20(%rdi), %r13
movslq %r13d, %rax
movq 0x2260(%r12,%rax,8), %rbx
movq 0x38(%rbx), %rbp
movl %r13d, 0x2258(%r12)
movq %rbx, %rdi
callq *%rbp
movq 0x8(%r15), %rax
incq %rax
movq %rax, 0x8(%r15)
cmpq %r14, %rax
jl 0xb500a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_do_setpif
static s7_pointer opt_do_setpif(opt_info *o)
                {
                    opt_info *o1;
                    int32_t loop;
                    s7_pointer vp, val, slot;
                    s7_int end, arg2;
                    s7_scheme *sc;
                    sc = o->sc;

                    oo_rc(sc, o, 10, 2);
                    end = o->v[1].i;
                    vp = o->v[6].p;
                    loop = o->v[4].i;
                    o1 = sc->opts[loop];
                    arg2 = o->v[3].i;
                    slot = o1->v[2].p;

                    val = make_mutable_integer(sc, integer(slot_value(o1->v[1].p)));
                    slot_set_value(o1->v[1].p, val);
                    while (integer(vp) < end)
                    {
                        integer(val) = o1->v[4].i_ii_f(integer(slot_value(slot)), arg2);
                        integer(vp)++;
                    }
                    clear_mutable_integer(val);
                    return(NULL);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x68(%rdi), %r14
movq 0x8(%rdi), %r15
movq 0x18(%rdi), %rbx
movq 0x30(%rdi), %r12
movslq 0x20(%rdi), %rax
movq 0x2260(%r14,%rax,8), %r13
movq 0x8(%r13), %rax
movq 0x10(%r13), %rbp
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xb508f
movq %r14, %rdi
movq %rdx, (%rsp)
callq 0xb389
movq (%rsp), %rdx
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r14
movq $0x500000b, (%r14)      # imm = 0x500000B
movq %rdx, 0x8(%r14)
movq 0x8(%r13), %rax
movq %r14, 0x10(%rax)
cmpq %r15, 0x8(%r12)
jge 0xb50e4
movq 0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq *0x20(%r13)
movq %rax, 0x8(%r14)
movq 0x8(%r12), %rax
incq %rax
movq %rax, 0x8(%r12)
cmpq %r15, %rax
jl 0xb50bf
andb $-0x5, 0x3(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_do_list_simple
static s7_pointer opt_do_list_simple(opt_info *o)
                {
                    /* 1 var, 1 expr, no return, step by cdr, end=null? */
                    opt_info *o1; /* o->v[2].p=frame, o->v[5].i=end index */
                    int32_t loop;
                    s7_pointer vp, old_e;
                    s7_scheme *sc;
                    s7_pointer (*fp)(opt_info *o);
                    sc = o->sc;

                    oo_rc(sc, o, 10, 0);
                    old_e = sc->envir;
                    push_stack_no_let_no_code(sc, OP_GC_PROTECT, old_e);
                    sc->envir = o->v[2].p;

                    vp = let_slots(o->v[2].p);
                    o1 = sc->opts[++sc->pc];
                    slot_set_value(vp, o1->v[0].fp(o1));

                    loop = sc->pc + 2;
                    o1 = sc->opts[loop];

                    fp = o1->v[0].fp;
                    if (fp == opt_if_bp) fp = opt_if_bp_nr;
                    while (!is_null(slot_value(vp)))
                    {
                        sc->pc = loop;
                        fp(o1);
                        slot_set_value(vp, cdr(slot_value(vp)));
                    }
                    sc->pc = o->v[5].i;
                    unstack(sc);
                    sc->envir = old_e;
                    return(sc->T);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r15
movq 0x8(%r15), %rcx
movq 0x50(%r15), %rax
movq %rcx, (%rsp)
movq %rcx, 0x10(%rax)
movq 0x50(%r15), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%r15)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%r15)
movq 0x10(%rdi), %rax
movq 0x8(%rax), %r13
movslq 0x2258(%r15), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r15)
movq 0x2268(%r15,%rax,8), %rdi
callq *(%rdi)
movq %rax, 0x10(%r13)
movslq 0x2258(%r15), %rbp
movq 0x2270(%r15,%rbp,8), %r14
movq (%r14), %rcx
leaq -0x1ea6(%rip), %rdx     # 0xb3430
cmpq %rdx, %rcx
leaq 0x141(%rip), %r12       # 0xb5421
cmovneq %rcx, %r12
cmpq 0x110(%r15), %rax
je 0xb5313
addq $0x2, %rbp
movl %ebp, 0x2258(%r15)
movq %r14, %rdi
callq *%r12
movq 0x10(%r13), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r13)
cmpq 0x110(%r15), %rax
jne 0xb52f1
movl 0x28(%rbx), %eax
movl %eax, 0x2258(%r15)
addq $-0x20, 0x50(%r15)
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movq 0x118(%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: tree_match
static bool tree_match(s7_pointer tree)
                {
                    if (is_symbol(tree))
                        return(is_matched_symbol(tree));
                    if (is_pair(tree))
                        return((tree_match(car(tree))) || (tree_match(cdr(tree))));
                    return(false);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rbx), %eax
cmpl $0x1, %eax
jne 0xb535f
movq 0x8(%rbx), %rdi
callq 0xb5340
testb %al, %al
jne 0xb5370
movq 0x10(%rbx), %rbx
jmp 0xb5344
cmpl $0xa, %eax
jne 0xb536c
movzwl (%rbx), %eax
shrl $0xf, %eax
jmp 0xb5372
xorl %eax, %eax
jmp 0xb5372
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: safe_stepper_expr
static bool safe_stepper_expr(s7_pointer expr, s7_pointer vars)
                {
                    /* for now, just look for stepper as last element of any list
                     *    any embedded set is handled by do_is_safe, so we don't need to descend into the depths
                     */
                    s7_pointer p;
                    if (direct_memq(cadr(expr), vars))
                        return(false);

                    for (p = cdr(expr); is_pair(cdr(p)); p = cdr(p));

                    if (is_pair(p))
                    {
                        if ((is_optimized(p)) &&
                                ((optimize_op(p) & 1) != 0) &&
                                (is_safe_c_op(optimize_op(p))))
                            return(true);

                        if (direct_memq(car(p), vars))
                            return(false);
                    }
                    else
                    {
                        if (direct_memq(p, vars))
                            return(false);
                    }
                    return(true);
                }

// Assembly:
movq 0x10(%rdi), %rax
movb (%rsi), %dl
cmpb $0x1, %dl
sete %cl
movl %ecx, %r8d
jne 0xb53a9
movq 0x8(%rax), %rdi
movl %ecx, %r8d
cmpq %rdi, 0x8(%rsi)
je 0xb53a9
movq %rsi, %r9
movq 0x10(%r9), %r9
cmpb $0x1, (%r9)
sete %r8b
jne 0xb53a9
cmpq %rdi, 0x8(%r9)
jne 0xb5395
testb %r8b, %r8b
jne 0xb541b
movq %rax, %rdi
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xb53ae
cmpb $0x1, (%rdi)
jne 0xb5400
cmpw $0x801, (%rdi)          # imm = 0x801
jne 0xb53e3
movl 0x4(%rdi), %r8d
movl %r8d, %eax
addl $-0x2, %eax
movzwl %ax, %eax
cmpl $0x9c, %eax
setb %r9b
movb $0x1, %al
testb %r9b, %r8b
jne 0xb541d
cmpb $0x1, %dl
jne 0xb5417
movq 0x8(%rdi), %rax
cmpq %rax, 0x8(%rsi)
je 0xb5417
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
sete %cl
je 0xb53ec
jmp 0xb5417
cmpb $0x1, %dl
jne 0xb5417
cmpq %rdi, 0x8(%rsi)
je 0xb5417
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
sete %cl
je 0xb5405
testb %cl, %cl
je 0xb541e
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_if_bp_nr
static s7_pointer opt_if_bp_nr(opt_info *o)
                {
                    oo_rc(o->sc, o, 6, 0);
                    o->sc->pc++;
                    if (o->v[3].fb(o->v[2].o1))
                    {
                        o->sc->pc++;
                        return(o->v[5].fp(o->v[4].o1));
                    }
                    return(NULL);
                }

// Assembly:
pushq %rbx
movq %rdi, %rcx
movq 0x68(%rdi), %rax
incl 0x2258(%rax)
movq 0x10(%rdi), %rdi
movq %rcx, %rbx
callq *0x18(%rcx)
testb %al, %al
je 0xb5452
movq %rbx, %rcx
movq 0x68(%rbx), %rax
incl 0x2258(%rax)
movq 0x20(%rbx), %rdi
popq %rbx
jmpq *0x28(%rcx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_p_pii_sff
static s7_pointer opt_p_pii_sff(opt_info *o)
                {
                    opt_info *o1;
                    s7_int i1, i2;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    i1 = o1->v[0].fi(o1);
                    o1 = sc->opts[++sc->pc];
                    i2 = o1->v[0].fi(o1);
                    oo_rc(sc, o, 5, 1);
                    return(o->v[4].p_pii_f(sc, slot_value(o->v[1].p), i1, i2));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
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
callq *(%rdi)
movq 0x8(%rbx), %rcx
movq 0x20(%rbx), %r8
movq 0x10(%rcx), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: vector_ref_p_pii_direct
static s7_pointer vector_ref_p_pii_direct(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2)
                {
                    if ((i1 < 0) || (i2 < 0) ||
                            (i1 >= vector_dimension(v, 0)) ||
                            (i2 >= vector_dimension(v, 1)))
                        return(g_vector_ref(sc, set_plist_3(sc, v, make_integer(sc, i1), make_integer(sc, i2))));
                    return(vector_element(v, i2 + (i1 * vector_offset(v, 0))));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rax
orq %rdx, %rax
js 0xb56ba
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %r12, (%rcx)
jle 0xb56ba
cmpq %r15, 0x8(%rcx)
jle 0xb56ba
movq 0x18(%rax), %rax
imulq (%rax), %r12
shlq $0x3, %r12
addq 0x10(%rbx), %r12
movq (%r12,%r15,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9928f(%rip), %rbp     # 0x14e950
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0xb56d1
movq (%rbp,%r12,8), %r13
jmp 0xb570b
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xb56e9
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r13
movq $0xb, (%r13)
movq %r12, 0x8(%r13)
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0xb571b
movq (%rbp,%r15,8), %rax
jmp 0xb5754
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xb5733
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
movq 0x718(%r14), %rsi
movq %rbx, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %r13, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7fcbd
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_p_call_any
static s7_pointer opt_p_call_any(opt_info *o)
                {
                    s7_pointer arg, val;
                    int32_t i;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 3, 0);
                    val = safe_list_if_possible(sc, o->v[1].i);
                    if (in_heap(val))
                        gc_protect_direct(sc, val);
                    for (i = 0, arg = val; i < o->v[1].i; i++, arg = cdr(arg))
                    {
                        opt_info *o1;
                        o1 = sc->opts[++sc->pc];
                        set_car(arg, o1->v[0].fp(o1));
                    }
                    arg = o->v[2].call(sc, val);
                    if (in_heap(val))
                        sc->stack_end -= 4;
                    else
                    {
                        clear_type_bit(T_Pair(val), T_LIST_IN_USE);
                        sc->current_safe_list = 0;
                    }
                    return(arg);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq 0x68(%rdi), %rbx
cmpq $0x7, %rsi
jg 0xb57c1
movq 0x1f38(%rbx,%rsi,8), %rax
testb $0x4, 0x1(%rax)
jne 0xb57c1
movl %esi, 0x2138(%rbx)
orb $0x4, 0x1(%rax)
movq 0x1f38(%rbx,%rsi,8), %r15
jmp 0xb57cc
movq %rbx, %rdi
callq 0xb587f
movq %rax, %r15
testb $0x40, 0x7(%r15)
jne 0xb57ef
movq 0x50(%rbx), %rax
movq $0x1, 0x18(%rax)
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r15, 0x10(%rax)
cmpq $0x0, 0x8(%r14)
jle 0xb5827
xorl %r12d, %r12d
movq %r15, %r13
movslq 0x2258(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq %rax, 0x8(%r13)
incq %r12
movq 0x10(%r13), %r13
cmpq %r12, 0x8(%r14)
jg 0xb57fc
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%r14)
testb $0x40, 0x7(%r15)
jne 0xb583f
addq $-0x20, 0x50(%rbx)
jmp 0xb584e
andb $-0x5, 0x1(%r15)
movl $0x0, 0x2138(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_safe_list
static s7_pointer make_safe_list(s7_scheme *sc, s7_int num_args)
                {
                    if (num_args < NUM_SAFE_LISTS)
                    {
                        sc->current_safe_list = num_args;
                        if (!is_pair(sc->safe_lists[num_args]))
                            sc->safe_lists[num_args] = permanent_list(sc, num_args);
                        if (!list_is_in_use(sc->safe_lists[num_args]))
                        {
                            set_list_in_use(sc->safe_lists[num_args]);
                            return(sc->safe_lists[num_args]);
                        }
                    }
                    return(make_big_list(sc, num_args, sc->nil));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x3f, %rsi
jg 0xb591f
movl %ebx, 0x2138(%r14)
movq 0x1f38(%r14,%rbx,8), %rax
cmpb $0x1, (%rax)
je 0xb58f6
movq 0x110(%r14), %r15
testq %rbx, %rbx
jle 0xb58eb
movabsq $0x4000000001000001, %r12 # imm = 0x4000000001000001
movq %rbx, %r13
movq 0x110(%r14), %rbp
movq %r14, %rdi
callq 0xfa3b
movq %r12, (%rax)
movq %rbp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, %r15
decq %r13
jne 0xb58c7
jmp 0xb58ee
movq %r15, %rax
movq %rax, 0x1f38(%r14,%rbx,8)
movq 0x1f38(%r14,%rbx,8), %rax
testb $0x4, 0x1(%rax)
jne 0xb591f
orb $0x4, 0x1(%rax)
movq 0x1f38(%r14,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%r14), %rdx
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa007d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_string_uncopied
static s7_pointer g_symbol_to_string_uncopied(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer sym;

        sym = car(args);
        if (!is_symbol(sym))
            return(method_or_bust_one_arg(sc, sym, sc->symbol_to_string_symbol, args, T_SYMBOL));
        if (is_gensym(sym))
            return(make_string_with_length(sc, symbol_name(sym), symbol_name_length(sym)));    /* return a copy of gensym name (which will be freed) */
        return(symbol_name_cell(sym));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0xb5d01
testb $0x20, 0x3(%rsi)
movq 0x8(%rsi), %rbx
je 0xb5cf2
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xb5c5e
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200013, (%rbx)       # imm = 0x200013
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xa305
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testq %r15, %r15
jle 0xb5ca2
movq %r12, %rsi
movq %r15, %rdx
callq 0x93e0
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r15)
movq %r15, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0xb5cdf
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x15c0(%r14), %rdx
movq %r14, %rdi
movl $0xa, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9b739