LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xac75f
leal 0x1(%rcx), %edx
movl %edx, 0x2258(%rax)
movslq %ecx, %rcx
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
jmp 0xac736
movq 0x10(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xac7ff
movq 0x68(%rbx), %rdi
movq 0x9e1a2(%rip), %rcx     # 0x14a968
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 0x38dfa
movq %r14, %rdi
callq *(%r14)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movl 0x10(%rbx), %ebp
decl %ebp
testl %ebp, %ebp
jle 0xac839
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 0xac816
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_O3/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 0xac8ac
pushq %rax
movq 0x8(%rdx), %rcx
cmpb $0x1, (%rcx)
jne 0xac89f
movq 0x8(%rcx), %r8
cmpq 0x18d8(%rdi), %r8
jne 0xac89f
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xac89f
cmpq %rsi, 0x8(%rcx)
je 0xac8ad
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
je 0xac87a
addq $0x8, %rsp
retq
movq 0x10(%rdx), %rdx
callq 0x38d02
xorb $0x1, %al
jmp 0xac8a8
// File: /workspace/github_c_makefile_star2_O3/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), %r12d
movslq 0x2258(%r15), %rax
leaq 0x1(%rax), %r13
movl %r13d, 0x2258(%r15)
movq 0x2268(%r15,%rax,8), %r14
movq %r14, %rdi
callq *(%r14)
testl %r12d, %r12d
je 0xac965
testb %al, %al
jne 0xac969
testl %r12d, %r12d
jle 0xac949
movl %r12d, %ebp
movslq 0x2258(%r15), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r15)
movq 0x2268(%r15,%rax,8), %rdi
callq *(%rdi)
decl %ebp
jne 0xac92a
movl %r13d, 0x2258(%r15)
movq %r14, %rdi
callq *(%r14)
jmp 0xac91e
movl %r13d, 0x2258(%r15)
movq %r14, %rdi
callq *(%r14)
testb %al, %al
je 0xac958
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_O3/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 0xacaa4
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 0xaca6f
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 0xacb03
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 0xacac0
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_O3/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 0xadddd
movq %r14, %rdi
movq %rdx, (%rsp)
callq 0xa550
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 0xade2b
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 0xade06
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_O3/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
movq (%r14), %rcx
leaq -0x1bc0(%rip), %rdx     # 0xac455
cmpq %rdx, %rcx
leaq 0x120(%rip), %r12       # 0xae13f
cmovneq %rcx, %r12
cmpq 0x110(%r15), %rax
je 0xae052
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 0xae030
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_O3/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 0xae09e
movq 0x8(%rbx), %rdi
callq 0xae07f
testb %al, %al
jne 0xae0af
movq 0x10(%rbx), %rbx
jmp 0xae083
cmpl $0xa, %eax
jne 0xae0ab
movzwl (%rbx), %eax
shrl $0xf, %eax
jmp 0xae0b1
xorl %eax, %eax
jmp 0xae0b1
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: safe_stepper_expr
static bool direct_memq(s7_pointer symbol, s7_pointer symbols)
    {
        s7_pointer x;
        for (x = symbols; is_pair(x); x = cdr(x))
            if (car(x) == symbol)
                return(true);
        return(false);
    }

// Assembly:
movb (%rsi), %dl
cmpb $0x1, %dl
jne 0xae0d0
movq 0x8(%rdi), %rax
movq %rsi, %rcx
cmpq %rax, 0x8(%rcx)
je 0xae13c
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0xae0c1
movq %rdi, %rcx
movq 0x10(%rdi), %rdi
cmpb $0x1, (%rdi)
je 0xae0d0
cmpb $0x1, (%rcx)
jne 0xae121
cmpw $0x801, (%rcx)          # imm = 0x801
jne 0xae103
movl 0x4(%rcx), %edi
movl %edi, %eax
addl $-0x2, %eax
movzwl %ax, %eax
cmpl $0x9c, %eax
setb %r8b
movb $0x1, %al
testb %r8b, %dil
jne 0xae120
movb $0x1, %al
cmpb $0x1, %dl
jne 0xae120
movq 0x8(%rcx), %rcx
cmpq %rcx, 0x8(%rsi)
setne %al
je 0xae120
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
je 0xae10e
retq
movb $0x1, %al
cmpb $0x1, %dl
jne 0xae120
cmpq %rcx, 0x8(%rsi)
setne %al
je 0xae120
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
je 0xae128
jmp 0xae120
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xae3d8
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %r12, (%rcx)
jle 0xae3d8
cmpq %r15, 0x8(%rcx)
jle 0xae3d8
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 0x98571(%rip), %rbp     # 0x146950
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0xae3ef
movq (%rbp,%r12,8), %r13
jmp 0xae429
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xae40e
movq %r14, %rdi
callq 0xa550
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 0xae439
movq (%rbp,%r15,8), %rax
jmp 0xae472
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xae458
movq %r14, %rdi
callq 0xa550
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 0x79c8d
// File: /workspace/github_c_makefile_star2_O3/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 0xae4df
movq 0x1f38(%rbx,%rsi,8), %rax
testb $0x4, 0x1(%rax)
jne 0xae4df
movl %esi, 0x2138(%rbx)
orb $0x4, 0x1(%rax)
movq 0x1f38(%rbx,%rsi,8), %r15
jmp 0xae4ea
movq %rbx, %rdi
callq 0xae59d
movq %rax, %r15
testb $0x40, 0x7(%r15)
jne 0xae50d
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 0xae545
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 0xae51a
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%r14)
testb $0x40, 0x7(%r15)
jne 0xae55d
addq $-0x20, 0x50(%rbx)
jmp 0xae56c
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_O3/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 0xae631
movl %ebx, 0x2138(%r14)
movq 0x1f38(%r14,%rbx,8), %rax
cmpb $0x1, (%rax)
je 0xae610
movq 0x110(%r14), %r15
testq %rbx, %rbx
jle 0xae605
movabsq $0x4000000001000001, %r12 # imm = 0x4000000001000001
movq %rbx, %r13
movq 0x110(%r14), %rbp
movq %r14, %rdi
callq 0xec9f
movq %r12, (%rax)
movq %rbp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, %r15
decq %r13
jne 0xae5e1
jmp 0xae608
movq %r15, %rax
movq %rax, 0x1f38(%r14,%rbx,8)
testb $0x4, 0x1(%rax)
jne 0xae631
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 0x997b7
// File: /workspace/github_c_makefile_star2_O3/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 0xae9b9
testb $0x20, 0x3(%rsi)
movq 0x8(%rsi), %rbx
je 0xae9aa
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xae91d
movq %r14, %rdi
callq 0xa550
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 0x9357
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testq %r15, %r15
jle 0xae95e
movq %r12, %rsi
movq %r15, %rdx
callq 0x83e0
movq 0x10(%rbx), %rdi
movb $0x0, (%rdi,%r15)
movq %r15, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0xae99e
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,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 0x95069
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0xa, (%rsi)
je 0xaea10
movq 0x15c0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0x9c0ab(%rip), %r8      # 0x14aab0
movq %r14, %rdi
movq %rbx, %rdx
callq 0xed2a
testb $0x20, 0x3(%rbx)
movq 0x8(%rbx), %rbx
je 0xaead2
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xaea45
movq %r14, %rdi
callq 0xa550
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 0x9357
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testq %r15, %r15
jle 0xaea86
movq %r12, %rsi
movq %r15, %rdx
callq 0x83e0
movq 0x10(%rbx), %rdi
movb $0x0, (%rdi,%r15)
movq %r15, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0xaeac6
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: p_pi_fc_combinable
static bool p_pi_fc_combinable(s7_scheme *sc, opt_info *opc)
                {
                    if ((sc->pc > 1) &&
                            (opc == sc->opts[sc->pc - 2]))
                    {
                        opt_info *o1;
                        o1 = sc->opts[sc->pc - 1];
                        if (o1->v[0].fp == opt_p_p_s)
                        {
                            opc->v[4].p_p_f = o1->v[2].p_p_f;
                            opc->v[1].p = o1->v[1].p;
                            opc->v[0].fp = opt_p_pi_fco;
                            backup_pc(sc);
                            return(oo_set_type_1(opc, 5, 1, OO_P));
                        }
                    }
                    return(return_false(sc, NULL, __func__, __LINE__));
                }

// Assembly:
movl 0x2258(%rdi), %eax
cmpl $0x2, %eax
jl 0xaedbe
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xaedbe
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq -0x3188(%rip), %rcx     # 0xabc31
cmpq %rcx, (%rax)
je 0xaedc1
xorl %eax, %eax
retq
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsi)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsi)
leaq 0xff(%rip), %rax        # 0xaeed7
movq %rax, (%rsi)
decl 0x2258(%rdi)
movabsq $0x100000005, %rax      # imm = 0x100000005
movq %rax, 0x60(%rsi)
movl $0x0, 0x70(%rsi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xaf121
leaq 0x6387d(%rip), %rsi     # 0x112985
leaq 0x68063(%rip), %r8      # 0x117172
movl $0x3, %edx
movq %rbx, %rcx
callq 0xd4e5
cmpb $0xb, (%rbx)
jne 0xaf127
movq 0x8(%rbx), %rax
jmp 0xaf129
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_O3/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 0xaf333
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x18(%r12)
cmpq 0x490(%rbx), %rax
je 0xaf367
movq %rax, %r14
movq 0x20(%rax), %rax
cmpb $0xb, (%rax)
je 0xaf311
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 0x9b7b3(%rip), %r8      # 0x14aab8
movq %rbx, %rdi
callq 0xed2a
movq 0x20(%r14), %rax
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r15
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0xaf385
leaq 0x97627(%rip), %rcx     # 0x146950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xaf3be
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 0x975ea(%rip), %rcx     # 0x146958
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x36924
movq 0x975d5(%rip), %rax     # 0x146958
jmp 0xaf3c2
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xaf3a4
movq %rbx, %rdi
callq 0xa550
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_O3/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 0xb11aa
cmpq %rdx, 0x110(%rdi)
jne 0xb1170
movq 0x150(%rdi), %rdx
testb $0x4, 0x2(%rdx)
jne 0xb11ab
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
movq 0x20(%rsi), %rdx
movl $0x18, %eax
cmpq %rdx, %rdi
je 0xb11a0
jle 0xb119b
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdi
cmpq %rdi, %rdx
jl 0xb118e
cmpq %rdx, %rdi
jne 0xb11ae
movq (%rsi,%rax), %rdx
cmpb $0x20, (%rdx)
sete %al
retq
xorl %eax, %eax
retq
movl $0x10, %eax
cmpb $0x1c, (%rcx)
jne 0xb11a0
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb11cd
cmpq %rsi, 0x8(%rdx)
je 0xb11a4
movq 0x18(%rdx), %rdx
jmp 0xb11bc
movq 0x10(%rcx), %rcx
jmp 0xb11b3
// File: /workspace/github_c_makefile_star2_O3/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 0xb14cc
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 0xb14c4
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_O3/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 0xb1550
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb1550
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_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_is_integer_s
static s7_pointer fx_is_integer_s(s7_scheme *sc, s7_pointer arg)
                {
#if WITH_GMP
                    return((s7_is_integer(lookup(sc, cadr(arg)))) ? sc->T : sc->F);
#else
                    return((is_t_integer(lookup(sc, cadr(arg)))) ? sc->T : sc->F);
#endif
                }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb194c
jle 0xb1947
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb193a
cmpq %rdx, %rsi
jne 0xb1965
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
xorl %ecx, %ecx
cmpb $0xb, (%rax)
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
cmpb $0x1c, (%rcx)
jne 0xb1985
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb197f
cmpq %rax, 0x8(%rdx)
je 0xb1950
movq 0x18(%rdx), %rdx
jmp 0xb196e
movq 0x10(%rcx), %rcx
jmp 0xb1965
movq 0x10(%rax), %rdx
jmp 0xb1950
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb1e10
jle 0xb1e0b
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb1dfe
cmpq %rdx, %rsi
jne 0xb1e23
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rsi
cmpb $0x1d, (%rsi)
jne 0xb1e43
movq 0x28(%rsi), %rax
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xb1e67
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb1e3d
cmpq %rax, 0x8(%rdx)
je 0xb1e14
movq 0x18(%rdx), %rdx
jmp 0xb1e2c
movq 0x10(%rcx), %rcx
jmp 0xb1e23
movq 0x11c8(%rdi), %rdx
movq 0x700(%rdi), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rdi), %rcx
movl $0x1d, %r8d
jmp 0x95069
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb1e14
xorl %esi, %esi
jmp 0xb1e18
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10(%rsi), %rdx
movq 0x8(%rdx), %rsi
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rsi), %r9
cmpq %r9, %rcx
je 0xb2156
movq %rax, %r8
movq %rcx, %r10
jle 0xb2151
movq %rax, %r8
movq 0x10(%r8), %r8
movq 0x18(%r8), %r10
cmpq %r10, %r9
jl 0xb2144
cmpq %r9, %r10
jne 0xb21af
movq 0x18(%rsi), %r9
movq 0x10(%r9), %rsi
movq 0x20(%rdx), %rdx
movq 0x20(%rdx), %r8
cmpq %r8, %rcx
je 0xb217f
jle 0xb217a
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
cmpq %rcx, %r8
jl 0xb216d
cmpq %r8, %rcx
jne 0xb21d0
movq 0x18(%rdx), %rcx
movq 0x10(%rcx), %rdx
cmpb $0xb, (%rsi)
jne 0x895ed
cmpb $0xb, (%rdx)
jne 0x895ed
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
cmpb $0x1c, (%r8)
jne 0xb21f0
movq 0x8(%r8), %r9
testq %r9, %r9
je 0xb21ca
cmpq %rsi, 0x8(%r9)
je 0xb215a
movq 0x18(%r9), %r9
jmp 0xb21b9
movq 0x10(%r8), %r8
jmp 0xb21af
cmpb $0x1c, (%rax)
jne 0xb2205
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xb21ea
cmpq %rdx, 0x8(%rcx)
je 0xb2183
movq 0x18(%rcx), %rcx
jmp 0xb21d9
movq 0x10(%rax), %rax
jmp 0xb21d0
movq 0x10(%rsi), %r9
cmpb $0x20, (%r9)
je 0xb215a
xorl %esi, %esi
jmp 0xb215e
movq 0x10(%rdx), %rcx
cmpb $0x20, (%rcx)
je 0xb2183
xorl %edx, %edx
jmp 0xb2187
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %rdx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rdx), %r9
cmpq %r9, %rcx
je 0xb2a6a
movq %rax, %r8
movq %rcx, %r10
jle 0xb2a65
movq %rax, %r8
movq 0x10(%r8), %r8
movq 0x18(%r8), %r10
cmpq %r10, %r9
jl 0xb2a58
cmpq %r9, %r10
jne 0xb2ab9
movq 0x18(%rdx), %r9
movq 0x10(%r9), %rdx
movq 0x20(%rsi), %rsi
movq 0x20(%rsi), %r8
cmpq %r8, %rcx
je 0xb2a93
jle 0xb2a8e
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
cmpq %rcx, %r8
jl 0xb2a81
cmpq %r8, %rcx
jne 0xb2ada
movq 0x18(%rsi), %rcx
movq 0x10(%rcx), %rcx
movl $0x118, %eax            # imm = 0x118
cmpq %rcx, %rdx
je 0xb2ab4
cmpb $0x5, (%rdx)
jne 0xb2aaf
cmpb $0x5, (%rcx)
je 0xb2ab4
movl $0x120, %eax            # imm = 0x120
movq (%rdi,%rax), %rax
retq
cmpb $0x1c, (%r8)
jne 0xb2afa
movq 0x8(%r8), %r9
testq %r9, %r9
je 0xb2ad4
cmpq %rdx, 0x8(%r9)
je 0xb2a6e
movq 0x18(%r9), %r9
jmp 0xb2ac3
movq 0x10(%r8), %r8
jmp 0xb2ab9
cmpb $0x1c, (%rax)
jne 0xb2b0f
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xb2af4
cmpq %rsi, 0x8(%rcx)
je 0xb2a97
movq 0x18(%rcx), %rcx
jmp 0xb2ae3
movq 0x10(%rax), %rax
jmp 0xb2ada
movq 0x10(%rdx), %r9
cmpb $0x20, (%r9)
je 0xb2a6e
xorl %edx, %edx
jmp 0xb2a72
movq 0x10(%rsi), %rcx
cmpb $0x20, (%rcx)
je 0xb2a97
xorl %ecx, %ecx
jmp 0xb2a9b
// File: /workspace/github_c_makefile_star2_O3/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 0xb2cff
pushq %rax
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
callq *0x18(%rsi)
movq 0x20(%rax), %rax
popq %rcx
retq
movq 0xf68(%rdi), %rdx
movl $0x1b, %r8d
movl $0x1, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_c_sss
static s7_pointer fx_c_sss(s7_scheme *sc, s7_pointer arg)
                {
                    set_car(sc->t3_1, lookup(sc, cadr(arg)));
                    set_car(sc->t3_2, lookup(sc, opt1_sym(cdr(arg)))); /* caddr(arg) */
                    set_car(sc->t3_3, lookup(sc, opt2_sym(cdr(arg)))); /* cadddr(arg) */
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xb3145
jle 0xb313c
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xb312f
cmpq %rdx, %r8
jne 0xb31e9
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x580(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rsi), %rax
movq 0x18(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xb3189
jle 0xb3180
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xb3173
cmpq %rdx, %r8
jne 0xb320d
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x588(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xb31c9
jle 0xb31c4
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xb31b7
cmpq %rdx, %r8
jne 0xb3231
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x590(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rsi), %rax
movq 0x580(%rdi), %rsi
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xb3251
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb3207
cmpq %rax, 0x8(%rdx)
je 0xb3149
movq 0x18(%rdx), %rdx
jmp 0xb31f2
movq 0x10(%rcx), %rcx
jmp 0xb31e9
cmpb $0x1c, (%rcx)
jne 0xb3265
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb322b
cmpq %rax, 0x8(%rdx)
je 0xb318d
movq 0x18(%rdx), %rdx
jmp 0xb3216
movq 0x10(%rcx), %rcx
jmp 0xb320d
cmpb $0x1c, (%rcx)
jne 0xb3279
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb324b
cmpq %rax, 0x8(%rdx)
je 0xb31cd
movq 0x18(%rdx), %rdx
jmp 0xb323a
movq 0x10(%rcx), %rcx
jmp 0xb3231
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb3149
xorl %eax, %eax
jmp 0xb314d
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb318d
xorl %eax, %eax
jmp 0xb3191
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb31cd
xorl %eax, %eax
jmp 0xb31d1
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_c_ssa
static s7_pointer fx_c_ssa(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    p = cddr(arg);
                    set_car(sc->t3_3, fx_call(sc, cdr(p)));
                    set_car(sc->t3_1, lookup(sc, cadr(arg)));
                    set_car(sc->t3_2, lookup(sc, car(p)));
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb33f3
jle 0xb33ee
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb33e1
cmpq %rdx, %rsi
jne 0xb3457
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb342f
jle 0xb342a
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb341d
cmpq %rdx, %rsi
jne 0xb3477
movq 0x18(%rax), %rdx
movq 0x10(%rdx), %rax
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xb3497
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb3471
cmpq %rax, 0x8(%rdx)
je 0xb33f7
movq 0x18(%rdx), %rdx
jmp 0xb3460
movq 0x10(%rcx), %rcx
jmp 0xb3457
cmpb $0x1c, (%rcx)
jne 0xb34ab
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xb3491
cmpq %rax, 0x8(%rdx)
je 0xb3433
movq 0x18(%rdx), %rdx
jmp 0xb3480
movq 0x10(%rcx), %rcx
jmp 0xb3477
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb33f7
xorl %eax, %eax
jmp 0xb33fb
movq 0x10(%rax), %rdx
cmpb $0x20, (%rdx)
je 0xb3433
xorl %eax, %eax
jmp 0xb3437
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_c_gac
static s7_pointer fx_c_gac(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    p = cdr(arg);
                    set_car(sc->t3_2, fx_call(sc, cdr(p)));
                    set_car(sc->t3_3, caddr(p));
                    set_car(sc->t3_1, lookup_global(sc, car(p)));
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rsi
testb $0x1, 0x2(%rsi)
jne 0xb3541
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rsi), %rcx
cmpq %rcx, %rdx
je 0xb352a
jle 0xb3525
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdx
cmpq %rdx, %rcx
jl 0xb3518
cmpq %rcx, %rdx
jne 0xb3569
movq 0x18(%rsi), %rcx
movq 0x10(%rcx), %rax
testq %rax, %rax
jne 0xb3549
movq %rbx, %rdi
callq 0x9c492
jmp 0xb3549
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%rax)
jne 0xb3589
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xb3583
cmpq %rsi, 0x8(%rcx)
je 0xb352e
movq 0x18(%rcx), %rcx
jmp 0xb3572
movq 0x10(%rax), %rax
jmp 0xb3569
movq 0x10(%rsi), %rcx
cmpb $0x20, (%rcx)
je 0xb352e
jmp 0xb3537
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_c_aaa
static s7_pointer fx_c_aaa(s7_scheme *sc, s7_pointer arg)
                {
                    check_stack_size(sc);
                    gc_protect_direct(sc, fx_call(sc, cdr(arg)));
                    sc->stack_end[-4] = fx_call(sc, cddr(arg));
                    set_car(sc->t3_3, fx_call(sc, cdddr(arg)));
                    set_car(sc->t3_2, sc->stack_end[-4]);
                    set_car(sc->t3_1, sc->stack_end[-2]);
                    sc->stack_end -= 4;
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq 0x58(%rdi), %rax
jb 0xb35b0
movq %rbx, %rdi
callq 0xb990b
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, -0x20(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x20(%rax), %rax
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax