LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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), %eax
decl %eax
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
incl %ebp
movslq 0x2258(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
decl %ebp
jne 0x88ef9
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_O2/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
movq %rdi, %rbx
pushq $-0x1
popq %r14
movq 0x68(%rbx), %rax
incq %r14
cmpq %r14, 0x8(%rbx)
jle 0x89047
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movq 0x68(%rbx), %rcx
cmpq 0x120(%rcx), %rax
je 0x89007
movl 0x10(%rbx), %edx
movl %edx, 0x2258(%rcx)
jmp 0x8904e
movq 0x120(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
movq 0x68(%rdi), %rcx
movq 0x118(%rcx), %rax
pushq $-0x1
popq %r14
incq %r14
cmpq %r14, 0x8(%rbx)
jle 0x890ac
movslq 0x2258(%rcx), %rax
leaq 0x1(%rax), %rdx
movl %edx, 0x2258(%rcx)
movq 0x2268(%rcx,%rax,8), %rdi
callq *(%rdi)
movq 0x68(%rbx), %rcx
movq 0x120(%rcx), %rdx
cmpq %rdx, %rax
jne 0x8906c
movl 0x10(%rbx), %eax
movl %eax, 0x2258(%rcx)
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp
static s7_pointer opt_if_nbp(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 2, 0);
                    o1 = o->sc->opts[++o->sc->pc];
                    if (!o1->v[0].fb(o1))
                    {
                        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 *(%rdi)
testb %al, %al
je 0x890f1
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 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
popq %rbx
jmpq *(%rdi)
// File: /workspace/github_c_makefile_star2_O2/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 0x8938f
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_O2/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 0x8948a
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_O2/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 0x894ed
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_O2/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 0x89649
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_O2/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 0x896ce
movq 0x28(%rbx), %rax
movq 0x20(%rax), %r14
movzbl (%r14), %eax
leaq 0x98a0c(%rip), %rcx     # 0x1220a0
cmpb $0x0, (%rax,%rcx)
je 0x896af
cmpb $0x1, (%r12)
jne 0x896e1
cmpq %r14, 0x8(%r12)
je 0x896ce
movq 0x10(%r12), %r12
jmp 0x8969a
cmpb $0x1, (%r12)
jne 0x896e1
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x32e3b
testb %al, %al
jne 0x896ce
movq 0x10(%r12), %r12
jmp 0x896af
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88edf
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_O2/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 0x89757
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
jmp 0x89730
movq 0x10(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x897f0
movq 0x68(%rbx), %rdi
movq 0x901aa(%rip), %rcx     # 0x119968
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), %rsi
callq 0x972b
movq %r14, %rdi
callq *(%r14)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movl 0x10(%rbx), %eax
decl %eax
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
incl %ebp
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 0x8980c
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_O2/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
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)
movl 0x18(%rdi), %eax
movslq 0x2258(%r15), %rcx
leaq 0x1(%rcx), %r13
movl %r13d, 0x2258(%r15)
movq 0x2268(%r15,%rcx,8), %r14
testl %eax, %eax
je 0x8992e
xorl %r12d, %r12d
testl %eax, %eax
cmovgl %eax, %r12d
movq %r14, %rdi
callq *(%r14)
testb %al, %al
jne 0x89938
movl %r12d, %ebp
subl $0x1, %ebp
jb 0x8991e
movslq 0x2258(%r15), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r15)
movq 0x2268(%r15,%rax,8), %rdi
callq *(%rdi)
jmp 0x898fc
movl %r13d, 0x2258(%r15)
jmp 0x898ef
movl %r13d, 0x2258(%r15)
movq %r14, %rdi
callq *(%r14)
testb %al, %al
je 0x89927
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_O2/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
subq $0x18, %rsp
movq 0x48(%rdi), %r14
movq 0x68(%rdi), %r12
movq 0x8(%r12), %rcx
movq 0x50(%r12), %rax
movq %rcx, 0x10(%rsp)
movq %rcx, 0x10(%rax)
movq 0x50(%r12), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%r12)
movq %rdi, 0x8(%rsp)
movq 0x10(%rdi), %rbx
movq %rbx, 0x8(%r12)
addq $0x8, %rbx
xorl %ebp, %ebp
movq (%rbx), %rbx
movslq 0x2258(%r12), %rax
leal 0x1(%rax), %r13d
movl %r13d, 0x2258(%r12)
movq 0x2268(%r12,%rax,8), %r15
testq %rbx, %rbx
je 0x89a28
movq %r15, %rdi
callq *(%r15)
movq %rax, 0x10(%rbx)
testb $-0x80, 0x2(%rbx)
cmovneq %rbx, %rbp
addq $0x18, %rbx
jmp 0x899b5
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)
movq %r15, %rdi
callq *(%r15)
testb %al, %al
je 0x899f1
movq 0x8(%rsp), %rbx
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 0x10(%rsp), %rcx
movq %rcx, 0x8(%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x68(%rdi), %r14
movq 0x8(%rdi), %r15
movq 0x20(%rdi), %r12
movq 0x30(%rdi), %r13
movslq %r12d, %rax
movq 0x2260(%r14,%rax,8), %rbx
movq 0x38(%rbx), %rbp
movq 0x8(%r13), %rax
cmpq %r15, %rax
jge 0x8ab27
movl %r12d, 0x2258(%r14)
movq %rbx, %rdi
callq *%rbp
movq 0x8(%r13), %rax
incq %rax
movq %rax, 0x8(%r13)
jmp 0x8ab09
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_O2/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 0x68(%rdi), %r14
movq 0x8(%rdi), %r15
movq 0x20(%rdi), %r12
movq 0x30(%rdi), %r13
movslq %r12d, %rax
movq 0x2260(%r14,%rax,8), %rbx
movq 0x38(%rbx), %rbp
movq 0x8(%r13), %rax
cmpq %r15, %rax
jge 0x8ab84
movl %r12d, 0x2258(%r14)
movq %rbx, %rdi
callq *%rbp
movq 0x8(%r13), %rax
incq %rax
movq %rax, 0x8(%r13)
jmp 0x8ab66
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_O2/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), %rax
movq 0x8(%rdi), %r15
movq 0x18(%rdi), %rbx
movq 0x30(%rdi), %r12
movslq 0x20(%rdi), %rcx
movq 0x2260(%rax,%rcx,8), %r13
movq 0x8(%r13), %rcx
movq 0x10(%r13), %rbp
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x7c936
movq %rax, %r14
movq 0x8(%r13), %rax
movq %r14, 0x10(%rax)
movq 0x8(%r12), %rax
cmpq %r15, %rax
jge 0x8ac0b
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)
jmp 0x8abe4
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_O2/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 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
addq $0x2, %rbp
movq (%r14), %rcx
leaq -0x199f(%rip), %rdx     # 0x89459
cmpq %rdx, %rcx
leaq 0xed(%rip), %r12        # 0x8aeef
cmovneq %rcx, %r12
cmpq 0x110(%r15), %rax
je 0x8ae2a
movl %ebp, 0x2258(%r15)
movq %r14, %rdi
callq *%r12
movq 0x10(%r13), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r13)
jmp 0x8ae06
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_O2/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 0x8ae76
movq 0x8(%rbx), %rdi
callq 0x8ae57
testb %al, %al
jne 0x8ae87
movq 0x10(%rbx), %rbx
jmp 0x8ae5b
cmpl $0xa, %eax
jne 0x8ae83
movzwl (%rbx), %eax
shrl $0xf, %eax
jmp 0x8ae89
xorl %eax, %eax
jmp 0x8ae89
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x8(%r14), %rdi
callq 0x7cf28
testb %al, %al
jne 0x8aee1
movq %r14, %rdi
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0x8aea3
cmpb $0x1, (%rdi)
jne 0x8aed5
cmpw $0x801, (%rdi)          # imm = 0x801
jne 0x8aed1
movl 0x4(%rdi), %ecx
movl %ecx, %eax
addl $-0x2, %eax
cmpw $0x9c, %ax
setb %dl
movb $0x1, %al
testb %dl, %cl
jne 0x8aee7
movq 0x8(%rdi), %rdi
movq %rbx, %rsi
callq 0x7cf28
testb %al, %al
je 0x8aee5
xorl %eax, %eax
jmp 0x8aee7
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8af20
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_O2/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 0x8b188
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %r12, (%rcx)
jle 0x8b188
cmpq %r15, 0x8(%rcx)
jle 0x8b188
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 0x8a7c1(%rip), %rbp     # 0x115950
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0x8b19f
movq (%rbp,%r12,8), %r13
jmp 0x8b1d9
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x8b1be
movq %r14, %rdi
callq 0x9c27
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 0x8b1e9
movq (%rbp,%r15,8), %rax
jmp 0x8b222
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x8b208
movq %r14, %rdi
callq 0x9c27
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 0x6278d
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq 0x8(%rdi), %rsi
movq 0x68(%rdi), %rbx
movq %rbx, %rdi
callq 0x8b2f5
movq %rax, %r14
testb $0x40, 0x7(%rax)
jne 0x8b294
movq 0x50(%rbx), %rax
movq $0x1, 0x18(%rax)
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r14, 0x10(%rax)
xorl %r12d, %r12d
movq %r14, %r13
cmpq %r12, 0x8(%r15)
jle 0x8b2c7
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
jmp 0x8b29a
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%r15)
testb $0x40, 0x7(%r14)
jne 0x8b2df
addq $-0x20, 0x50(%rbx)
jmp 0x8b2eb
andb $-0x5, 0x1(%r14)
andl $0x0, 0x2138(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: safe_list_if_possible
static inline s7_pointer safe_list_if_possible(s7_scheme *sc, s7_int num_args)
                {
                    if ((num_args < NUM_SAFE_PRELISTS) &&
                            (!list_is_in_use(sc->safe_lists[num_args])))
                    {
                        sc->current_safe_list = num_args;
                        set_list_in_use(sc->safe_lists[num_args]);
                        return(sc->safe_lists[num_args]);
                    }
                    return(make_safe_list(sc, num_args));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x7, %rsi
jg 0x8b31c
movq 0x1f38(%r14,%rbx,8), %rax
testb $0x4, 0x1(%rax)
jne 0x8b32a
movl %ebx, 0x2138(%r14)
jmp 0x8b34f
cmpq $0x40, %rbx
jae 0x8b363
movq 0x1f38(%r14,%rbx,8), %rax
movl %ebx, 0x2138(%r14)
cmpb $0x1, (%rax)
je 0x8b349
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c2e2
movq %rax, 0x1f38(%r14,%rbx,8)
testb $0x4, 0x1(%rax)
jne 0x8b363
orb $0x4, 0x1(%rax)
movq 0x1f38(%r14,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x110(%r14), %rdx
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7adde
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x8b61f
testb $0x20, 0x3(%rsi)
movq 0x8(%rsi), %rax
jne 0x8b62f
retq
movq 0x15c0(%rdi), %rdx
pushq $0xa
popq %r8
jmp 0x77745
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rsi
jmp 0xd11d
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: symbol_to_string_uncopied_p
static s7_pointer symbol_to_string_uncopied_p(s7_scheme *sc, s7_pointer sym)
    {
        if (!is_symbol(sym))
            simple_wrong_type_argument(sc, sc->symbol_to_string_symbol, sym, T_SYMBOL);
        if (is_gensym(sym))
            return(make_string_with_length(sc, symbol_name(sym), symbol_name_length(sym)));
        return(symbol_name_cell(sym));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0xa, (%rsi)
je 0x8b66f
movq 0x15c0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0x8e44c(%rip), %r8      # 0x119ab0
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd456
testb $0x20, 0x3(%r14)
movq 0x8(%r14), %rax
jne 0x8b682
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd11d
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: int_vector_set_unchecked_p
static s7_pointer int_vector_set_unchecked_p(s7_scheme *sc, s7_pointer v, s7_int i, s7_pointer p)
                {
                    if (!s7_is_integer(p))
                        s7_wrong_type_arg_error(sc, "int-vector-set!", 3, p, "an integer");
                    int_vector(v, i) = s7_integer(p);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
cmpb $0xb, (%rcx)
je 0x8bc96
leaq 0x52ca6(%rip), %rsi     # 0xde925
leaq 0x5748c(%rip), %r8      # 0xe3112
pushq $0x3
popq %rdx
movq %rbx, %rcx
callq 0xc2b0
cmpb $0xb, (%rbx)
jne 0x8bc9c
movq 0x8(%rbx), %rax
jmp 0x8bc9e
xorl %eax, %eax
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r14,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_hash_increment_1
static inline s7_pointer fx_hash_increment_1(s7_scheme *sc, s7_pointer table, s7_pointer key, s7_pointer arg)
                {
                    hash_entry_t *val;
                    if (!is_hash_table(table))
                        return(((s7_p_ppp_t)opt2_direct(cdr(arg)))(sc, table, key, fx_call(sc, cdddr(arg))));
                    val = (*hash_table_checker(table))(sc, table, key);
                    if (val != sc->unentry)
                    {
                        if (!is_t_integer(hash_entry_value(val)))
                            simple_wrong_type_argument(sc, sc->add_symbol, cadddr(arg), T_INTEGER);

                        hash_entry_set_value(val, make_integer(sc, integer(hash_entry_value(val)) + 1));
                        return(hash_entry_value(val));
                    }
                    s7_hash_table_set(sc, table, key, small_int(1));
                    return(small_int(1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpb $0x1b, (%rsi)
jne 0x8beb8
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x18(%r12)
cmpq 0x490(%rbx), %rax
je 0x8beec
movq %rax, %r14
movq 0x20(%rax), %rax
cmpb $0xb, (%rax)
je 0x8be96
movq 0xba8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%r13), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq 0x140(%rbx), %rcx
movq 0x8dc2e(%rip), %r8      # 0x119ab8
movq %rbx, %rdi
callq 0xd456
movq 0x20(%r14), %rax
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r15
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0x8bf0a
leaq 0x89aa2(%rip), %rcx     # 0x115950
movq 0x8(%rcx,%rax,8), %rax
jmp 0x8bf43
movq 0x10(%r13), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rax), %r14
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
movq 0x89a65(%rip), %rcx     # 0x115958
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2a7e4
movq 0x89a50(%rip), %rax     # 0x115958
jmp 0x8bf47
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x8bf29
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x20(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: let_symbol_is_safe
static bool let_symbol_is_safe(s7_scheme *sc, s7_pointer sym, s7_pointer e)
    {
        if (is_slot(global_slot(sym)))
            return(true);
        if (is_null(e))
            e = sc->rootlet;
        return((!is_with_let_let(e)) &&
                (is_slot(symbol_to_slot(sc, sym))));
    }

// Assembly:
movq 0x10(%rsi), %rcx
movb $0x1, %al
cmpb $0x20, (%rcx)
je 0x8d7cc
cmpq %rdx, 0x110(%rdi)
jne 0x8d7b6
movq 0x150(%rdi), %rdx
testb $0x4, 0x2(%rdx)
jne 0x8d7cd
pushq %rax
callq 0xb00b
cmpb $0x20, (%rax)
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_or_and_2
static s7_pointer fx_or_and_2(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p, val;
                    p = cdr(arg);
                    val = fx_call(sc, p);
                    if (val != sc->F) return(val);
                    p = cdadr(p);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    return(fx_call(sc, cdr(p)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r14), %rsi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x8d9ae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x8d9a6
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_and_3
static s7_pointer fx_and_3(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p, val;
                    p = cdr(arg);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    p = cdr(p);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    return(fx_call(sc, cdr(p)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r14), %rsi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x8da32
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x8da32
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_or_and_3
static s7_pointer fx_or_and_3(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p, val;
                    p = cdr(arg);
                    val = fx_call(sc, p);
                    if (val != sc->F) return(val);
                    p = cdadr(p);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    p = cdr(p);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    return(fx_call(sc, cdr(p)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r14), %rsi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x8da5e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x8da56
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x8da56
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_iterate_p_p
static s7_pointer fx_iterate_p_p(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer iter;
                    iter = lookup(sc, cadr(arg));
                    if (is_iterator(iter))
                        return((iterator_next(iter))(sc, iter));
                    return(method_or_bust_one_arg(sc, iter, sc->iterate_symbol, set_plist_1(sc, iter), T_ITERATOR));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
cmpb $0x1d, (%rax)
jne 0x8dda4
movq 0x28(%rax), %rcx
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmpq *%rcx
movq 0x11c8(%rbx), %rdx
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rcx
pushq $0x1d
popq %r8
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x77745
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_ss
static s7_pointer fx_num_eq_ss(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    x = lookup(sc, cadr(arg));
                    y = lookup(sc, opt2_sym(cdr(arg)));
                    if ((is_t_integer(x)) && (is_t_integer(y)))
                        return(make_boolean(sc, integer(x) == integer(y)));
                    return(num_eq_p_pp(sc, x, y));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x8(%r15), %rsi
callq 0x7d158
movq %rax, %r14
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x7d158
cmpb $0xb, (%r14)
jne 0x8df43
cmpb $0xb, (%rax)
jne 0x8df43
movq 0x8(%r14), %rcx
xorl %edx, %edx
cmpq 0x8(%rax), %rcx
setne %dl
movq 0x118(%rbx,%rdx,8), %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x6e8d2
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_is_eq_ss
static s7_pointer fx_is_eq_ss(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    x = lookup(sc, cadr(arg));
                    y = lookup(sc, opt2_sym(cdr(arg)));
                    return(make_boolean(sc, (x == y) || ((is_unspecified(x)) && (is_unspecified(y)))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x8(%r15), %rsi
callq 0x7d158
movq %rax, %r14
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x7d158
movl $0x118, %ecx            # imm = 0x118
cmpq %rax, %r14
je 0x8e34f
cmpb $0x5, (%r14)
jne 0x8e34a
cmpb $0x5, (%rax)
je 0x8e34f
movl $0x120, %ecx            # imm = 0x120
movq (%rbx,%rcx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table_ref_2
static s7_pointer g_hash_table_ref_2(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer table;
                    table = car(args);
                    if (!is_hash_table(table))
                        return(method_or_bust(sc, table, sc->hash_table_ref_symbol, args, T_HASH_TABLE, 1));
                    return(hash_entry_value((*hash_table_checker(table))(sc, table, cadr(args))));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x1b, (%rsi)
jne 0x8e40d
pushq %rax
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
callq *0x18(%rsi)
movq 0x20(%rax), %rax
popq %rcx
retq
movq 0xf68(%rdi), %rdx
pushq $0x1b
popq %r8
pushq $0x1
popq %r9
jmp 0xcd70