LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opsq_cs
static s7_pointer fx_c_opsq_cs(s7_scheme *sc, s7_pointer arg)
                {
                    set_car(sc->t1_1, lookup(sc, opt3_sym(cdr(arg))));  /* cadadr(arg); */
                    set_car(sc->t3_1, c_call(cadr(arg))(sc, sc->t1_1));
                    set_car(sc->t3_2, opt1_con(cdr(arg)));              /* caddr(arg) or cadr(caddr(arg)) */
                    set_car(sc->t3_3, lookup(sc, opt2_sym(cdr(arg))));  /* cadddr(arg); */
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x28(%rax), %rsi
callq 0x7d158
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x18(%rax), %rax
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
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: op_call_with_exit
static s7_pointer op_call_with_exit(s7_scheme *sc)
    {
        s7_pointer go, args;
        set_current_code(sc, sc->code);
        args = opt2_pair(sc->code);
        go = make_goto(sc);
        push_stack_no_let_no_code(sc, OP_DEACTIVATE_GOTO, go); /* was also pushing code */
        new_frame_with_slot(sc, sc->envir, sc->envir, caar(args), go);
        sc->code = T_Pair(cdr(args));
        return(NULL);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x28(%rdi)
movq 0x20(%rax), %r15
callq 0xa24ad
movq %rax, %r14
movq 0x50(%rbx), %rax
movq %r14, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x204, 0x18(%rax)      # imm = 0x204
addq $0x20, 0x50(%rbx)
movq 0x8(%r15), %rax
movq 0x8(%rax), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x96d1f
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x20001c, (%rax)       # imm = 0x20001C
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq $0x20, (%rcx)
movq %r12, 0x8(%rcx)
movq %r14, 0x10(%rcx)
movq %rcx, 0x18(%r12)
movq 0x250(%rbx), %rdx
movq %rdx, 0x20(%r12)
incl 0x28(%r12)
andq $0x0, 0x18(%rcx)
movq %rcx, 0x8(%rax)
movq 0x10(%r15), %rax
movq %rax, (%rbx)
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: closure_is_ok_1
static inline bool closure_is_ok_1(s7_scheme *sc, s7_pointer code, uint16_t type, int32_t args)
                {
                    s7_pointer f;
#if S7_DEBUGGING
                    if ((type & (T_ONE_FORM | T_MULTIFORM)) == 0) fprintf(stderr, "%s %s: type has no body bits\n", __func__, DISPLAY(code));
#endif
                    f = lookup_unexamined(sc, car(code));
                    if ((f == opt1_lambda_unchecked(code)) ||
                            ((f) &&
                             (typesflag(f) == type) &&
                             ((closure_arity(f) == args) || (closure_arity_to_int(sc, f) == args)) && /* 3 type bits to replace this but not hit enough to warrant them */
                             (set_opt1_lambda(code, f))))
                        return(true);
                    sc->last_function = f;
                    return(false);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rsi
callq 0x7d158
cmpq 0x18(%rbx), %rax
je 0x96e0b
movq %rax, %r14
testq %rax, %rax
je 0x96df9
cmpw %r12w, (%r14)
jne 0x96df9
addq $0x18, %rbx
movb $0x1, %r12b
cmpl %ebp, 0x28(%r14)
je 0x96e06
movq %r15, %rdi
movq %r14, %rsi
callq 0xa2581
cmpl %ebp, %eax
je 0x96e06
addq $0x1ed8, %r15           # imm = 0x1ED8
xorl %r12d, %r12d
movq %r15, %rbx
movq %r14, (%rbx)
jmp 0x96e0e
movb $0x1, %r12b
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: closure_is_fine_1
static inline bool closure_is_fine_1(s7_scheme *sc, s7_pointer code, uint16_t type, int32_t args)
                {
                    s7_pointer f;
#if S7_DEBUGGING
                    if ((type & (T_ONE_FORM | T_MULTIFORM)) != 0) fprintf(stderr, "%s %s: type has body bits\n", __func__, DISPLAY(code));
#endif
                    f = lookup_unexamined(sc, car(code));
                    if ((f == opt1_lambda_unchecked(code)) ||
                            ((f) &&
                             ((typesflag(f) & (TYPE_MASK | T_SAFE_CLOSURE)) == type) &&
                             ((closure_arity(f) == args) || (closure_arity_to_int(sc, f) == args)) &&
                             (set_opt1_lambda(code, f))))
                        return(true);
                    sc->last_function = f;
                    return(false);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rsi
callq 0x7d158
cmpq 0x18(%rbx), %rax
je 0x97090
movq %rax, %r14
testq %rax, %rax
je 0x9707e
movzwl (%r14), %eax
andl $0x10ff, %eax           # imm = 0x10FF
cmpw %r12w, %ax
jne 0x9707e
addq $0x18, %rbx
movb $0x1, %r12b
cmpl %ebp, 0x28(%r14)
je 0x9708b
movq %r15, %rdi
movq %r14, %rsi
callq 0xa2581
cmpl %ebp, %eax
je 0x9708b
addq $0x1ed8, %r15           # imm = 0x1ED8
xorl %r12d, %r12d
movq %r15, %rbx
movq %r14, (%rbx)
jmp 0x97093
movb $0x1, %r12b
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_safe_closure_a_a
static s7_pointer fx_safe_closure_a_a(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer result;
                    gc_protect_direct(sc, sc->envir);
                    sc->envir = old_frame_with_slot(sc, closure_let(opt1_lambda(code)), fx_call(sc, cdr(code)));
                    result = fx_call(sc, closure_body(opt1_lambda(code)));
                    sc->envir = sc->stack_end[-2];
                    sc->stack_end -= 4;
                    return(result);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rdi), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rdi)
movq %rax, 0x10(%rcx)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x18(%rcx), %r15
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x92a16
movq %r15, 0x8(%rbx)
movq 0x18(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, 0x8(%rbx)
addq $-0x20, %rcx
movq %rcx, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_safe_closure_ss_a
static s7_pointer fx_safe_closure_ss_a(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer result;
                    gc_protect_direct(sc, sc->envir);
                    sc->envir = old_frame_with_two_slots(sc, closure_let(opt1_lambda(code)), lookup(sc, cadr(code)), lookup(sc, opt2_sym(code)));
                    result = fx_call(sc, closure_body(opt1_lambda(code)));
                    sc->envir = sc->stack_end[-2];
                    sc->stack_end -= 4;
                    return(result);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rdi), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rdi)
movq %rax, 0x10(%rcx)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x18(%rcx), %r15
movq 0x8(%rax), %rsi
callq 0x7d158
movq %rax, %r12
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0xa5d8d
movq %r15, 0x8(%rbx)
movq 0x18(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, 0x8(%rbx)
addq $-0x20, %rcx
movq %rcx, 0x50(%rbx)
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: op_closure_3s
static void op_closure_3s(s7_scheme *sc)
                {
                    s7_pointer e, p, args, last_slot;
                    s7_int id;
                    check_stack_size(sc);
                    args = cdr(sc->code);
                    sc->code = opt1_lambda(sc->code);

                    new_frame(sc, closure_let(sc->code), e);
                    sc->z = e;
                    id = let_id(e);
                    p = closure_args(sc->code);
                    add_slot(e, car(p), lookup(sc, car(args)));
                    last_slot = let_slots(e);
                    p = cdr(p);
                    args = cdr(args);
                    add_slot_at_end(id, last_slot, car(p), lookup(sc, car(args)));
                    add_slot_at_end(id, last_slot, cadr(p), lookup(sc, cadr(args)));

                    sc->envir = e;
                    sc->z = sc->nil;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq 0x58(%rdi), %rax
jb 0x98350
movq %rbx, %rdi
callq 0x91caf
movq (%rbx), %rcx
movq 0x90(%rbx), %rax
movq 0x10(%rcx), %r12
movq 0x18(%rcx), %rcx
movq %rcx, (%rbx)
cmpq 0x98(%rbx), %rax
ja 0x9837d
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x20001c, (%r14)       # imm = 0x20001C
movq 0x250(%rbx), %rax
incq %rax
movq %rax, 0x250(%rbx)
movq %rax, 0x18(%r14)
andq $0x0, 0x8(%r14)
movq (%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%r14)
movq %r14, 0x4f0(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x8(%rsp)
movq (%rbx), %rax
movq 0x8(%rax), %r13
movq 0x8(%r13), %r15
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %rbp
pushq $0x20
popq %rcx
movq %rcx, (%rbp)
movq %r15, 0x8(%rbp)
movq %rax, 0x10(%rbp)
movq %rbp, 0x18(%r15)
movq 0x18(%r14), %rax
movq %rax, 0x20(%r15)
incl 0x28(%r15)
movq 0x8(%r14), %rax
movq %rax, 0x18(%rbp)
movq %rbp, 0x8(%r14)
movq 0x10(%r13), %r15
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %r13
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %r12
pushq $0x20
popq %rcx
movq %rcx, (%r12)
movq %r13, 0x8(%r12)
andq $0x0, 0x18(%r12)
movq %rax, 0x10(%r12)
movq %r12, 0x18(%r13)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r13)
incl 0x28(%r13)
movq %r12, 0x18(%rbp)
movq 0x10(%r15), %rax
movq 0x8(%rax), %r15
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %rcx
pushq $0x20
popq %rdx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
andq $0x0, 0x18(%rcx)
movq %rax, 0x10(%rcx)
movq %rcx, 0x18(%r15)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r15)
incl 0x28(%r15)
movq %rcx, 0x18(%r12)
movq %r14, 0x8(%rbx)
movq 0x110(%rbx), %rax
movq %rax, 0x4f0(%rbx)
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: fx_safe_closure_aa_a
static s7_pointer fx_safe_closure_aa_a(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer p;
                    p = cdr(code);
                    gc_protect_direct(sc, sc->envir);
                    sc->stack_end[-4] = fx_call(sc, cdr(p));
                    sc->stack_end[-3] = fx_call(sc, p);
                    p = opt1_lambda(sc->code);
                    sc->envir = old_frame_with_two_slots(sc, closure_let(p), sc->stack_end[-3], sc->stack_end[-4]);
                    p = fx_call(sc, closure_body(p));
                    sc->envir = sc->stack_end[-2];
                    sc->stack_end -= 4;
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rdi), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rdi)
movq %rax, 0x10(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, -0x20(%rcx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x50(%rbx), %rcx
movq %rax, -0x18(%rcx)
movq (%rbx), %rax
movq 0x50(%rbx), %rdx
movq 0x18(%rax), %r15
movq 0x18(%r15), %r14
movq -0x20(%rdx), %rcx
movq -0x18(%rdx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa5d8d
movq %r14, 0x8(%rbx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, 0x8(%rbx)
addq $-0x20, %rcx
movq %rcx, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_safe_closure_fp_1
static void op_safe_closure_fp_1(s7_scheme *sc)
                {
                    /* in-coming sc->value has the current arg value, sc->args is all previous args */
                    uint64_t id;
                    s7_pointer x, z;

                    sc->args = safe_reverse_in_place(sc, sc->args);
                    sc->code = opt1_lambda(car(sc->args));
                    sc->args = cdr(sc->args);

                    id = ++sc->let_number;
                    sc->envir = closure_let(sc->code);
                    let_id(sc->envir) = id;

                    for (x = let_slots(sc->envir), z = sc->args; tis_slot(x); x = next_slot(x), z = cdr(z))
                    {
                        slot_set_value(x, car(z));
                        symbol_set_local(slot_symbol(x), id, x);
                    }
                    if (is_pair(z))  /* these checks are needed because multiple-values might evade earlier arg num checks */
                        s7_error(sc, sc->wrong_number_of_args_symbol, set_elist_3(sc, too_many_arguments_string, sc->code, sc->args));
                    if (tis_slot(x))
                        s7_error(sc, sc->wrong_number_of_args_symbol, set_elist_3(sc, not_enough_arguments_string, sc->code, sc->args));

                    sc->code = closure_body(sc->code);
                    if (is_pair(cdr(sc->code)))
                        push_stack_no_args(sc, sc->begin_op, cdr(sc->code));
                    sc->code = car(sc->code);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0x10(%rdi), %rsi
callq 0xa833
movq %rax, 0x10(%rbx)
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
movq 0x250(%rbx), %rax
incq %rax
movq %rax, 0x250(%rbx)
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x18(%rcx)
movq 0x8(%rbx), %rcx
addq $0x8, %rcx
movq (%r14), %r14
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x98aa6
movq 0x8(%r14), %rdx
movq %rdx, 0x10(%rcx)
movq 0x8(%rcx), %rdx
movq %rcx, 0x18(%rdx)
movq 0x8(%rcx), %rdx
movq %rax, 0x20(%rdx)
movq 0x8(%rcx), %rdx
incl 0x28(%rdx)
addq $0x18, %rcx
addq $0x10, %r14
jmp 0x98a72
cmpb $0x1, (%r14)
jne 0x98aeb
movq 0x1900(%rbx), %rsi
movq 0x895de(%rip), %rax     # 0x122098
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
movq 0x6e8(%rbx), %rdi
movq %rax, 0x8(%rdi)
movq 0x10(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x6e8(%rbx), %rdx
movq %rbx, %rdi
callq 0x2cdc0
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rbx)
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x98b28
movq 0x50(%rbx), %rax
movq %rcx, (%rax)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x688(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x18(%rcx)
addq $0x20, 0x50(%rbx)
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_tc_and_a_or_a_la
static void op_tc_and_a_or_a_la(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer fx_and, fx_or, fx_la, la_slot;

                    fx_and = cdr(code);           /* first clause of and */
                    fx_or = cdadr(fx_and);        /* same or */
                    fx_la = cdadr(fx_or);
                    la_slot = let_slots(sc->envir);
                    /* cell_optimize here is slower! */
                    while (true)
                    {
                        s7_pointer p;
                        p = fx_call(sc, fx_and);
                        if (p == sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_or);
                        if (p != sc->F) {sc->value = p; return;}
                        slot_set_value(la_slot, fx_call(sc, fx_la));
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r12
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r13
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x98bd1
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
jne 0x98bd1
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq %rax, 0x10(%r13)
jmp 0x98b96
movq %rax, 0x20(%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: op_tc_or_a_and_a_la
static void op_tc_or_a_and_a_la(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer fx_and, fx_or, fx_la, la_slot;

                    fx_or = cdr(code);             /* first clause of or */
                    fx_and = cdadr(fx_or);         /* same and */
                    fx_la = cdadr(fx_and);
                    la_slot = let_slots(sc->envir);

                    while (true)
                    {
                        s7_pointer p;
                        p = fx_call(sc, fx_or);
                        if (p != sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_and);
                        if (p == sc->F) {sc->value = p; return;}
                        slot_set_value(la_slot, fx_call(sc, fx_la));
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r12
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r13
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
jne 0x98c4a
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
je 0x98c4a
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq %rax, 0x10(%r13)
jmp 0x98c0f
movq %rax, 0x20(%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: op_tc_and_a_or_a_laa
static void op_tc_and_a_or_a_laa(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer fx_and, fx_or, fx_la, la_slot, fx_laa, laa_slot;

                    fx_and = cdr(code);           /* first clause of and */
                    fx_or = cdadr(fx_and);        /* same or */
                    fx_la = cdadr(fx_or);
                    la_slot = let_slots(sc->envir);
                    fx_laa = cdr(fx_la);
                    laa_slot = next_slot(la_slot);

                    while (true)
                    {
                        s7_pointer p;
                        p = fx_call(sc, fx_and);
                        if (p == sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_or);
                        if (p != sc->F) {sc->value = p; return;}
                        slot_set_value(la_slot, fx_call(sc, fx_la));
                        slot_set_value(laa_slot, fx_call(sc, fx_laa));
                    }
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r12
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r13
movq 0x10(%r12), %rbp
movq 0x18(%r13), %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0x98ce4
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
jne 0x98ce4
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq %rax, 0x10(%r13)
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq (%rsp), %rcx
movq %rax, 0x10(%rcx)
jmp 0x98c97
movq %rax, 0x20(%rbx)
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: op_tc_or_a_and_a_laa
static void op_tc_or_a_and_a_laa(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer fx_and, fx_or, fx_la, la_slot, fx_laa, laa_slot;

                    fx_or = cdr(code);             /* first clause of or */
                    fx_and = cdadr(fx_or);         /* same and */
                    fx_la = cdadr(fx_and);
                    la_slot = let_slots(sc->envir);
                    fx_laa = cdr(fx_la);
                    laa_slot = next_slot(la_slot);

                    while (true)
                    {
                        s7_pointer p;
                        p = fx_call(sc, fx_or);
                        if (p != sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_and);
                        if (p == sc->F) {sc->value = p; return;}
                        slot_set_value(la_slot, fx_call(sc, fx_la));
                        slot_set_value(laa_slot, fx_call(sc, fx_laa));
                    }
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r12
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r13
movq 0x10(%r12), %rbp
movq 0x18(%r13), %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
jne 0x98d83
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
je 0x98d83
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq %rax, 0x10(%r13)
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq (%rsp), %rcx
movq %rax, 0x10(%rcx)
jmp 0x98d36
movq %rax, 0x20(%rbx)
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: op_tc_or_a_a_and_a_a_la
static void op_tc_or_a_a_and_a_a_la(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer fx_and1, fx_and2, fx_or1, fx_or2, fx_la, la_slot;

                    fx_or1 = cdr(code);            /* first clause of or */
                    fx_or2 = cdr(fx_or1);
                    fx_and1 = cdadr(fx_or2);       /* same and */
                    fx_and2 = cdr(fx_and1);
                    fx_la = cdadr(fx_and2);
                    la_slot = let_slots(sc->envir);

                    while (true)
                    {
                        s7_pointer p;
                        p = fx_call(sc, fx_or1);
                        if (p != sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_or2);
                        if (p != sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_and1);
                        if (p == sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_and2);
                        if (p == sc->F) {sc->value = p; return;}
                        slot_set_value(la_slot, fx_call(sc, fx_la));
                    }
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x10(%r14), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r12
movq 0x10(%r12), %r13
movq 0x10(%r13), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rbp
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
jne 0x98e3b
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
jne 0x98e3b
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
cmpq 0x120(%rbx), %rax
je 0x98e3b
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
cmpq 0x120(%rbx), %rax
je 0x98e3b
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq (%rsp), %rcx
movq %rax, 0x10(%rcx)
jmp 0x98dd5
movq %rax, 0x20(%rbx)
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: op_tc_or_a_and_a_a_l3a
static void op_tc_or_a_and_a_a_l3a(s7_scheme *sc, bool or_case, s7_pointer code)
                {
                    s7_pointer fx_and1, fx_and2, fx_or, fx_la, la_slot, fx_laa, laa_slot, fx_l3a, l3a_slot;

                    fx_or = cdr(code);             /* first clause of or */
                    fx_and1 = (or_case) ? cdadr(fx_or) : cdaddr(fx_or);
                    fx_and2 = cdr(fx_and1);
                    fx_la = cdadr(fx_and2);
                    la_slot = let_slots(sc->envir);
                    fx_laa = cdr(fx_la);
                    laa_slot = next_slot(la_slot);
                    fx_l3a = cdr(fx_laa);
                    l3a_slot = next_slot(laa_slot);

                    while (true)
                    {
                        s7_pointer p;
                        p = fx_call(sc, fx_or);
                        if (p != sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_and1);
                        if (p == sc->F) {sc->value = p; return;}
                        p = fx_call(sc, fx_and2);
                        if (p == sc->F) {sc->value = p; return;}
                        slot_set_value(la_slot, fx_call(sc, fx_la));
                        slot_set_value(laa_slot, fx_call(sc, fx_laa));
                        slot_set_value(l3a_slot, fx_call(sc, fx_l3a));
                    }
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
jne 0x98e75
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %r12
movq 0x10(%r12), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r13
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x10(%r13), %rbp
movq %rax, 0x20(%rsp)
movq 0x18(%rax), %rax
movq 0x10(%rbp), %r14
movq %rax, 0x18(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
cmpq 0x120(%rbx), %rax
jne 0x98f38
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
je 0x98f38
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
cmpq 0x120(%rbx), %rax
je 0x98f38
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
movq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq 0x18(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
jmp 0x98eb9
movq %rax, 0x20(%rbx)
addq $0x28, %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: op_tc_if_a_z_if_a_z_laa
static bool op_tc_if_a_z_if_a_z_laa(s7_scheme *sc, bool cond, s7_pointer code)
                {
                    s7_pointer if_test, if_true, if_false, f_test, f_true, la, la_slot, laa, laa_slot, endp;
                    if_test = (cond) ? cadr(code) : cdr(code);
                    if_true = cdr(if_test);
                    if (!cond) if_false = cadr(if_true);
                    f_test = (cond) ? caddr(code) : cdr(if_false);
                    f_true = cdr(f_test);
                    la = (cond) ?  cdadr(cadddr(code)) : cdadr(f_true);
                    la_slot = let_slots(sc->envir);
                    laa = cdr(la);
                    laa_slot = next_slot(la_slot);

                    while (true)
                    {
                        s7_pointer a1;
                        if (fx_call(sc, if_test) != sc->F) {endp = if_true; break;}
                        if (fx_call(sc, f_test) != sc->F) {endp = f_true; break;}
                        a1 = fx_call(sc, la);
                        sc->w = a1;
                        slot_set_value(laa_slot, fx_call(sc, laa));
                        slot_set_value(la_slot, a1);
                    }
                    return(op_tc_z(sc, endp));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdx), %r12
testl %esi, %esi
je 0x99219
movq 0x10(%r12), %rax
movq 0x8(%r12), %r12
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %r13
movq 0x10(%rax), %rax
movq 0x10(%r13), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
jmp 0x99238
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r13
movq 0x10(%r13), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rbp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x10(%rbp), %r14
movq %rax, 0x20(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
cmpq 0x120(%rbx), %rax
jne 0x992bb
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
cmpq 0x120(%rbx), %rax
jne 0x992c2
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq %rax, %r15
movq %rax, 0x4d8(%rbx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x18(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq 0x20(%rsp), %rax
movq %r15, 0x10(%rax)
jmp 0x9925e
movq 0x10(%rsp), %rsi
jmp 0x992c7
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa5fb5
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_tc_cond_a_z_a_laa_laa
static bool op_tc_cond_a_z_a_laa_laa(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer c1, c2, c3, la1, la2, laa1, laa2, la_slot, laa_slot;
                    c1 = cadr(code);
                    c2 = caddr(code);
                    la1 = cdadr(c2);
                    laa1 = cddadr(c2);
                    c3 = cadr(cadddr(code));
                    la2 = cdr(c3);
                    laa2 = cddr(c3);
                    la_slot = let_slots(sc->envir);
                    laa_slot = next_slot(la_slot);
                    while (true)
                    {
                        s7_pointer a1;
                        if (fx_call(sc, c1) != sc->F) {c1 = cdr(c1); break;}
                        if (fx_call(sc, c2) != sc->F)
                        {
                            a1 = fx_call(sc, la1);
                            sc->w = a1;
                            slot_set_value(laa_slot, fx_call(sc, laa1));
                        }
                        else
                        {
                            a1 = fx_call(sc, la2);
                            sc->w = a1;
                            slot_set_value(laa_slot, fx_call(sc, laa2));
                        }
                        slot_set_value(la_slot, a1);
                    }
                    return(op_tc_z(sc, c1));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%rax), %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %rax
movq 0x10(%r12), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r13
movq 0x18(%r13), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
jne 0x993b5
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rbp
cmpq 0x120(%rbx), %rax
je 0x99388
movq 0x8(%rsp), %rcx
movq (%rsp), %rbp
movq 0x8(%rcx), %rsi
movq %rbx, %rdi
callq *0x20(%rcx)
movq %rax, %r14
movq %rax, 0x4d8(%rbx)
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %r14, 0x10(%r13)
jmp 0x9934b
movq 0x10(%r15), %rsi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa5fb5
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_tc_if_a_z_la
static bool op_tc_if_a_z_la(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer if_test, if_true, la, la_slot;
                    if_test = cdr(code);
                    if_true = cdr(if_test);
                    la = cdadr(if_true);
                    la_slot = let_slots(sc->envir);

                    if (is_t_integer(slot_value(la_slot)))
                    {
                        sc->pc = 0;
                        reset_opts(sc);
                        if (bool_optimize(sc, if_test))
                        {
                            opt_info *o, *o1;
                            o = sc->opts[0];
                            o1 = sc->opts[sc->pc];
                            if (int_optimize(sc, la))
                            {
                                s7_pointer val;
                                slot_set_value(la_slot, val = make_mutable_integer(sc, integer(slot_value(la_slot))));
                                while (true)
                                {
                                    sc->pc = 0;
                                    if (o->v[0].fb(o)) break;
                                    sc->pc++;
                                    integer(val) = o1->v[0].fi(o1);
                                }
                                return(op_tc_z(sc, if_true));
                            }
                        }
                    }
                    while (true)
                    {
                        if (fx_call(sc, if_test) != sc->F) break;
                        slot_set_value(la_slot, fx_call(sc, la));
                    }
                    return(op_tc_z(sc, if_true));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r12
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r14
movq 0x10(%r14), %rax
cmpb $0xb, (%rax)
jne 0x99799
andl $0x0, 0x2258(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x87220
testb %al, %al
je 0x99799
movq 0x2260(%rbx), %r13
movslq 0x2258(%rbx), %rax
movq 0x2260(%rbx,%rax,8), %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7e94f
testb %al, %al
je 0x99799
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7c936
movq %rax, %r15
movq %rax, 0x10(%r14)
andl $0x0, 0x2258(%rbx)
movq %r13, %rdi
callq *(%r13)
testb %al, %al
jne 0x997ad
incl 0x2258(%rbx)
movq %rbp, %rdi
callq *(%rbp)
movq %rax, 0x8(%r15)
jmp 0x99764
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq %rax, 0x10(%r14)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
je 0x99788
movq %rbx, %rdi
movq (%rsp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa5fb5
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_tc_if_a_la_z
static bool op_tc_if_a_la_z(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer if_test, if_false, la, la_slot;
                    if_test = cdr(code);
                    if_false = cddr(if_test);
                    la = cdadr(if_test);
                    la_slot = let_slots(sc->envir);

                    if (is_t_integer(slot_value(la_slot)))
                    {
                        sc->pc = 0;
                        reset_opts(sc);
                        if (bool_optimize(sc, if_test))
                        {
                            opt_info *o, *o1;
                            o = sc->opts[0];
                            o1 = sc->opts[sc->pc];
                            if (int_optimize(sc, la))
                            {
                                s7_pointer val;
                                slot_set_value(la_slot, val = make_mutable_integer(sc, integer(slot_value(la_slot))));
                                while (true)
                                {
                                    sc->pc = 0;
                                    if (o->v[0].fb(o))
                                    {
                                        sc->pc++;
                                        integer(val) = o1->v[0].fi(o1);
                                    }
                                    else break;
                                }
                                return(op_tc_z(sc, if_false));
                            }
                        }
                    }

                    while (true)
                    {
                        if (fx_call(sc, if_test) == sc->F) break;
                        slot_set_value(la_slot, fx_call(sc, la));
                    }
                    return(op_tc_z(sc, if_false));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rcx), %r12
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r14
movq 0x10(%r14), %rax
cmpb $0xb, (%rax)
jne 0x99bec
andl $0x0, 0x2258(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x87220
testb %al, %al
je 0x99bec
movq 0x2260(%rbx), %r13
movslq 0x2258(%rbx), %rax
movq 0x2260(%rbx,%rax,8), %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7e94f
testb %al, %al
je 0x99bec
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7c936
movq %rax, %r15
movq %rax, 0x10(%r14)
andl $0x0, 0x2258(%rbx)
movq %r13, %rdi
callq *(%r13)
testb %al, %al
je 0x99c00
incl 0x2258(%rbx)
movq %rbp, %rdi
callq *(%rbp)
movq %rax, 0x8(%r15)
jmp 0x99bb7
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq %rax, 0x10(%r14)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
cmpq 0x120(%rbx), %rax
jne 0x99bdb
movq %rbx, %rdi
movq (%rsp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa5fb5
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_tc_if_a_z_if_a_laa_z
static bool op_tc_if_a_z_if_a_laa_z(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer if_test, if_true, if_false, f_test, f_true, f_false, la, la_slot, laa, laa_slot, endp;
                    if_test = cdr(code);
                    if_true = cdr(if_test);
                    if_false = cadr(if_true);
                    f_test = cdr(if_false);
                    f_true = cdr(f_test);
                    f_false = cdr(f_true);
                    la = cdar(f_true);
                    la_slot = let_slots(sc->envir);
                    laa = cdr(la);
                    laa_slot = next_slot(la_slot);

                    while (true)
                    {
                        s7_pointer a1;
                        if (fx_call(sc, if_test) != sc->F) {endp = if_true; break;}
                        if (fx_call(sc, f_test) == sc->F) {endp = f_false; break;}
                        a1 = fx_call(sc, la);
                        sc->w = a1;
                        slot_set_value(laa_slot, fx_call(sc, laa));
                        slot_set_value(la_slot, a1);
                    }
                    return(op_tc_z(sc, endp));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %r12
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r13
movq 0x10(%r13), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rcx), %rbp
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rbp), %r14
movq %rax, 0x20(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
cmpq 0x120(%rbx), %rax
jne 0x9a24c
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
cmpq 0x120(%rbx), %rax
je 0x9a253
movq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rbp)
movq %rax, %r15
movq %rax, 0x4d8(%rbx)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x18(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq 0x20(%rsp), %rax
movq %r15, 0x10(%rax)
jmp 0x9a1ef
movq 0x10(%rsp), %rsi
jmp 0x9a258
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa5fb5
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_recur_if_a_a_opla_la_laq
static void opinit_if_a_a_opla_la_laq(s7_scheme *sc, bool a_op)
                {
                    s7_pointer caller;
                    rec_set_test(sc, cdr(sc->code));
                    rec_set_res(sc, (a_op) ?  cddr(sc->code) : cdddr(sc->code));
                    caller = opt3_pair(sc->code);
                    rec_set_f1(sc, cdadr(caller));
                    rec_set_f2(sc, cdaddr(caller));
                    rec_set_f3(sc, cdr(opt3_pair(caller)));
                    sc->rec_slot1 = let_slots(sc->envir);
                    sc->rec_call = c_callee(caller);
                }

// Assembly:
movq (%rdi), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x2f0(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x360(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f0(%rdi)
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x340(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x3b0(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x340(%rdi)
movq 0x28(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x2f8(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x368(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f8(%rdi)
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x300(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x370(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x300(%rdi)
movq 0x28(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x308(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x378(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x308(%rdi)
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x348(%rdi)
movq 0x20(%rax), %rax
movq %rax, 0x3b8(%rdi)
jmp 0xa7576
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_recur_cond_a_a_opa_laq
static void opinit_cond_a_a_opa_laq(s7_scheme *sc)
                {
                    s7_pointer caller;
                    rec_set_test(sc, cadr(sc->code));
                    rec_set_res(sc, cdadr(sc->code));
                    caller = opt3_pair(sc->code);
                    rec_set_f1(sc, cdr(caller));
                    rec_set_f2(sc, cdr(opt3_pair(caller)));
                    sc->rec_slot1 = let_slots(sc->envir);
                    sc->rec_call = c_callee(caller);
                }

// Assembly:
movq (%rdi), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f0(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x360(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f0(%rdi)
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x340(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x3b0(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x340(%rdi)
movq 0x28(%rax), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x2f8(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x368(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f8(%rdi)
movq 0x28(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x300(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x370(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x300(%rdi)
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x348(%rdi)
movq 0x20(%rax), %rax
movq %rax, 0x3b8(%rdi)
jmp 0xa60e1
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_recur_cond_a_a_a_a_opa_laaq
static void opinit_cond_a_a_a_a_opa_laaq(s7_scheme *sc)
                {
                    s7_pointer caller;
                    rec_set_test(sc, cadr(sc->code));
                    rec_set_res(sc, cdadr(sc->code));

                    sc->rec_f1p = caddr(sc->code);
                    rec_set_f2(sc, cdr(sc->rec_f1p));
                    sc->rec_f1f = c_callee(sc->rec_f1p);
                    sc->rec_f1p = car(sc->rec_f1p);
                    caller = opt3_pair(sc->code);
                    rec_set_f3(sc, cdr(caller));
                    rec_set_f4(sc, opt3_pair(caller));
                    rec_set_f5(sc, cdr(opt3_pair(caller)));
                    sc->rec_slot1 = let_slots(sc->envir);
                    sc->rec_slot2 = next_slot(sc->rec_slot1);
                    sc->rec_call = c_callee(caller);
                }

// Assembly:
movq (%rdi), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f0(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x360(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f0(%rdi)
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x340(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x3b0(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x340(%rdi)
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f8(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x300(%rdi)
movq 0x20(%rdx), %rsi
movq %rsi, 0x370(%rdi)
movq 0x8(%rdx), %rdx
movq %rdx, 0x300(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x368(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2f8(%rdi)
movq 0x28(%rax), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x308(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x378(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x308(%rdi)
movq 0x28(%rax), %rcx
movq %rcx, 0x310(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x380(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x310(%rdi)
movq 0x28(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x318(%rdi)
movq 0x20(%rcx), %rdx
movq %rdx, 0x388(%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x318(%rdi)
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x348(%rdi)
movq 0x18(%rcx), %rcx
movq %rcx, 0x350(%rdi)
movq 0x20(%rax), %rax
movq %rax, 0x3b8(%rdi)
jmp 0xa7c10