LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: lookup
static inline s7_pointer lookup(s7_scheme *sc, s7_pointer symbol) /* lookup_checked includes the unbound_variable call */
#endif
        {
            s7_pointer x;
            if (let_id(sc->envir) == symbol_id(symbol))
                return(slot_value(local_slot(symbol)));
            for (x = sc->envir; symbol_id(symbol) < let_id(x); x = outlet(x));
            if (let_id(x) == symbol_id(symbol))
                return(slot_value(local_slot(symbol)));
            for (; is_let(x); x = outlet(x))
            {
                s7_pointer y;
                for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                    if (slot_symbol(y) == symbol)
                        return(slot_value(y));
            }
            /* if (is_global(symbol)) fprintf(stderr, "%s in %s\n", DISPLAY(symbol), DISPLAY_80(sc->code)); */
            x = global_slot(symbol);
            if (is_slot(x)) return(slot_value(x));
#if WITH_GCC
            return(NULL); /* much faster than various alternatives */
#else
            return(unbound_variable(sc, symbol));
#endif
        }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rsi), %rcx
cmpq %rcx, %rdx
je 0x7d17a
cmpq %rdx, %rcx
jge 0x7d178
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdx
jmp 0x7d169
jne 0x7d183
movq 0x18(%rsi), %rcx
movq 0x10(%rcx), %rax
retq
cmpb $0x1c, (%rax)
jne 0x7d1a6
leaq 0x8(%rax), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x7d1a0
cmpq %rsi, 0x8(%rcx)
je 0x7d17e
addq $0x18, %rcx
jmp 0x7d18c
movq 0x10(%rax), %rax
jmp 0x7d183
movq 0x10(%rsi), %rcx
cmpb $0x20, (%rcx)
je 0x7d17e
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fill_star_defaults
static inline void fill_star_defaults(s7_scheme *sc, s7_pointer func, int32_t start_arg, int32_t n_args, s7_pointer par)
                {
                    int32_t i;
                    s7_pointer *df;
                    df = c_function_arg_defaults(func);

                    if (c_func_has_simple_defaults(func))
                    {
                        for (i = start_arg; i < n_args; i++, par = cdr(par))
                            set_car(par, df[i]);
                    }
                    else
                    {
                        for (i = start_arg; i < n_args; i++, par = cdr(par))
                        {
                            s7_pointer defval;
                            defval = df[i];
                            if (is_symbol(defval))
                                set_car(par, lookup_checked(sc, defval));
                            else
                            {
                                if (is_pair(defval))
                                    set_car(par, s7_eval(sc, defval, sc->nil));
                                else set_car(par, defval);
                            }
                        }
                    }
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq 0x8(%rsi), %rax
movq 0x50(%rax), %r12
testb $0x4, 0x2(%rsi)
jne 0x7da2b
movq %rdi, %r14
movslq %edx, %r13
movslq %ecx, %rbp
cmpq %rbp, %r13
jge 0x7da47
movq (%r12,%r13,8), %r15
movzbl (%r15), %eax
cmpl $0x1, %eax
je 0x7da07
cmpl $0xa, %eax
jne 0x7da1b
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d158
testq %rax, %rax
jne 0x7da1e
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d1b2
jmp 0x7da1e
movq 0x110(%r14), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ad8f
jmp 0x7da1e
movq %r15, %rax
movq %rax, 0x8(%rbx)
incq %r13
movq 0x10(%rbx), %rbx
jmp 0x7d9d3
movslq %edx, %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x7da47
movq (%r12,%rax,8), %rdx
movq %rdx, 0x8(%rbx)
incq %rax
movq 0x10(%rbx), %rbx
jmp 0x7da31
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: set_file_and_line_number
static void set_file_and_line_number(s7_scheme *sc, s7_pointer p)
                {
                    if (sc->input_port != sc->standard_input) /* (port_file_number(sc->input_port) > 1) -- maybe 0 is legit? */
                    {
                        pair_set_line_number(p, port_line_number(sc->input_port));
                        pair_set_file(p, port_file_number(sc->input_port));
                        set_has_line_number(p);	      /* sc->input_port above can't be nil(?) -- it falls back on stdin now */
                    }
                }

// Assembly:
movq 0x170(%rdi), %rax
cmpq 0x1c8(%rdi), %rax
je 0x7da8c
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x2c(%rsi)
movq 0x170(%rdi), %rax
movq 0x8(%rax), %rax
movl 0x24(%rax), %eax
movl %eax, 0x28(%rsi)
orb $0x4, 0x2(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: find_autoload_name
static const char *find_autoload_name(s7_scheme *sc, s7_pointer symbol, bool *already_loaded, bool loading)
    {
        s7_int l = 0, lib, libs;
        const char *name;

        name = symbol_name(symbol);
        libs = sc->autoload_names_loc;

        for (lib = 0; lib < libs; lib++)
        {
            const char **names;
            s7_int u;
            u = sc->autoload_names_sizes[lib] - 1;
            names = sc->autoload_names[lib];

            while (true)
            {
                s7_int comp, pos;
                const char *this_name;
                if (u < l) break;
                pos = (l + u) / 2;
                this_name = names[pos * 2];
                comp = strcmp(this_name, name);
                if (comp == 0)
                {
                    *already_loaded = sc->autoloaded_already[lib][pos];
                    if (loading) sc->autoloaded_already[lib][pos] = true;
                    return(names[pos * 2 + 1]);             /* file name given func name */
                }
                if (comp < 0)
                    l = pos + 1;
                else u = pos - 1;
            }
        }
        return(NULL);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0x4(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x8(%rsi), %rax
movq 0x2178(%rdi), %rdx
xorl %ecx, %ecx
testq %rdx, %rdx
cmovleq %rcx, %rdx
movq 0x10(%rax), %r13
xorl %esi, %esi
xorl %ebx, %ebx
movq %rdi, 0x8(%rsp)
movq %rdx, 0x20(%rsp)
cmpq %rdx, %rsi
je 0x7db8b
movq 0x2160(%rdi), %rax
movq 0x2168(%rdi), %rcx
movq (%rcx,%rsi,8), %r12
decq %r12
movq %rsi, 0x10(%rsp)
movq (%rax,%rsi,8), %r15
cmpq %rbx, %r12
jl 0x7db32
leaq (%rbx,%r12), %r14
movq %r14, %rbp
shrq %rbp
movq %r14, %rax
movabsq $0x1ffffffffffffffe, %rcx # imm = 0x1FFFFFFFFFFFFFFE
andq %rcx, %rax
movq (%r15,%rax,8), %rdi
movq %r13, %rsi
callq 0x8370
testl %eax, %eax
je 0x7db46
js 0x7db2a
decq %rbp
movq %rbp, %r12
jmp 0x7daf1
incq %rbp
movq %rbp, %rbx
jmp 0x7daf1
movq 0x10(%rsp), %rsi
incq %rsi
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rdx
jmp 0x7daca
movq 0x8(%rsp), %rax
movq 0x2170(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movb (%rax,%rbp), %cl
movq 0x18(%rsp), %rdx
movb %cl, (%rdx)
cmpb $0x0, 0x4(%rsp)
je 0x7db70
movb $0x1, (%rax,%rbp)
shlq $0x3, %r14
orq $0x8, %r14
movq (%r15,%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x7db7c
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: d_7piid_ok
static bool d_7piid_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_7piid_t f;
                    f = s7_d_7piid_function(s_func);
                    if ((f) &&
                            (is_symbol(cadr(car_x))))
                    {
                        opc->v[4].d_7piid_f = f;
                        if (car(car_x) == sc->float_vector_set_symbol)
                            return(opt_float_vector_set(sc, opc, cadr(car_x), cddr(car_x), cdddr(car_x), cddddr(car_x)));
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x7
popq %rsi
movq %rdx, %rdi
callq 0x366a7
testq %rax, %rax
je 0x7e180
movq 0x10(%r15), %rcx
movq 0x8(%rcx), %rcx
cmpb $0xa, (%rcx)
jne 0x7e180
movq %rax, 0x20(%rbx)
movq 0x8(%r15), %rax
cmpq 0xef8(%r14), %rax
je 0x7e188
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %r8
movq 0x10(%r8), %r9
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7e374
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_macroexpand
static s7_pointer s7_macroexpand(s7_scheme *sc, s7_pointer mac, s7_pointer args)
                {
                    push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                    sc->code = mac;
                    sc->args = copy_list_with_arglist_error(sc, args);
                    new_frame(sc, closure_let(sc->code), sc->envir);
                    eval(sc, OP_APPLY_LAMBDA);
                    return(sc->value);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1df, 0x18(%rax)      # imm = 0x1DF
addq $0x20, 0x50(%rdi)
movq %rsi, (%rdi)
movq %rdx, %rsi
callq 0x94b91
movq %rax, 0x10(%rbx)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x7e211
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)
andq $0x0, 0x8(%rax)
movq (%rbx), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movl $0x311, %esi            # imm = 0x311
movq %rbx, %rdi
callq 0xe1a8
movq 0x20(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_real_symbol
static s7_pointer opt_real_symbol(s7_scheme *sc, s7_pointer sym)
                {
                    if (is_symbol(sym))
                    {
                        s7_pointer p;
                        p = symbol_to_slot(sc, sym);
                        if ((is_slot(p)) &&
                                (is_real(slot_value(p))))
                            return(p);
                    }
                    return(NULL);
                }

// Assembly:
cmpb $0xa, (%rsi)
jne 0x7e294
pushq %rax
callq 0xb00b
cmpb $0x20, (%rax)
jne 0x7e28d
movq 0x10(%rax), %rcx
movzbl (%rcx), %ecx
leaq 0x9b729(%rip), %rdx     # 0x1199b0
cmpb $0x0, (%rcx,%rdx)
jne 0x7e28f
xorl %eax, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_set_d_d_f
static s7_double opt_set_d_d_f(opt_info *o)
                {
                    opt_info *o1;
                    s7_double x;
                    o1 = o->sc->opts[++o->sc->pc];
                    x = o1->v[0].fd(o1);
                    oo_rc(o->sc, o, 2, 1);
                    slot_set_value(o->v[1].p, make_real(o->sc, x));
                    return(x);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x7e34b
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_integer_symbol
static s7_pointer opt_integer_symbol(s7_scheme *sc, s7_pointer sym)
                {
                    if (is_symbol(sym))
                    {
                        s7_pointer p;
                        p = symbol_to_slot(sc, sym);
                        if ((is_slot(p)) &&
                                (is_opt_int(slot_value(p))))
                            return(p);
                    }
                    return(NULL);
                }

// Assembly:
cmpb $0xa, (%rsi)
jne 0x7e6d7
pushq %rax
callq 0xb00b
cmpb $0x20, (%rax)
jne 0x7e6d0
movq 0x10(%rax), %rcx
cmpb $0xb, (%rcx)
je 0x7e6d2
xorl %eax, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_float_symbol
static s7_pointer opt_float_symbol(s7_scheme *sc, s7_pointer sym)
                {
                    if (is_symbol(sym))
                    {
                        s7_pointer p;
                        p = symbol_to_slot(sc, sym);
                        if ((is_slot(p)) &&
                                (is_float(slot_value(p))))
                            return(p);
                    }
                    return(NULL);
                }

// Assembly:
cmpb $0xa, (%rsi)
jne 0x7e704
pushq %rax
callq 0xb00b
cmpb $0x20, (%rax)
jne 0x7e6fd
movq 0x10(%rax), %rcx
cmpb $0xd, (%rcx)
je 0x7e6ff
xorl %eax, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: i_7piii_ok
static bool i_7piii_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_i_7piii_t f;
                    f = s7_i_7piii_function(s_func);
                    if ((f) &&
                            (is_symbol(cadr(car_x))))
                    {
                        s7_pointer settee;
                        if ((car(car_x) == sc->int_vector_set_symbol) || (car(car_x) == sc->byte_vector_set_symbol))
                            return(opt_int_vector_set(sc, (car(car_x) == sc->int_vector_set_symbol) ? OO_IV : OO_BV, opc, cadr(car_x), cddr(car_x), cdddr(car_x), cddddr(car_x)));

                        settee = symbol_to_slot(sc, cadr(car_x));
                        if (is_slot(settee))
                        {
                            s7_pointer vect;
                            vect = slot_value(settee);
                            if ((is_int_vector(vect)) && (vector_rank(vect) == 3))
                            {
                                opc->v[5].i_7piii_f = f;
                                opc->v[1].p = settee;
                                return(opt_i_7piii_args(sc, opc, OO_IV, cddr(car_x), cdddr(car_x), cddddr(car_x)));
                            }
                        }
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rsi
movq %rdx, %rdi
callq 0x366a7
testq %rax, %rax
je 0x80135
movq %rax, %r12
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
cmpb $0xa, (%rcx)
jne 0x80135
movq 0x8(%r15), %rdx
cmpq 0xfb0(%r14), %rdx
je 0x80143
cmpq 0xc38(%r14), %rdx
je 0x80147
movq %r14, %rdi
movq %rcx, %rsi
callq 0xb00b
cmpb $0x20, (%rax)
jne 0x80135
movq 0x10(%rax), %rcx
cmpb $0x16, (%rcx)
jne 0x80135
movq 0x18(%rcx), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x80135
cmpq $0x3, 0x10(%rcx)
jne 0x80135
movq %r12, 0x28(%rbx)
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %r8
movq 0x10(%r8), %r9
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x805e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x4
jmp 0x80149
pushq $0xa
popq %rsi
movq 0x10(%rax), %r8
movq 0x10(%r8), %r9
movq 0x10(%r9), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x80239
jmp 0x80137
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_set_i_i_f
static s7_int opt_set_i_i_f(opt_info *o)
                {
                    opt_info *o1;
                    s7_int x;
                    oo_rc(o->sc, o, 2, 1);
                    o1 = o->sc->opts[++o->sc->pc];
                    x = o1->v[0].fi(o1);
                    slot_set_value(o->v[1].p, make_integer(o->sc, x));
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x801e8
leaq 0x9576e(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x80226
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x8020c
callq 0x9c27
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_simple_symbol
static s7_pointer opt_simple_symbol(s7_scheme *sc, s7_pointer sym)
                {
                    s7_pointer p;
                    p = symbol_to_slot(sc, sym);
                    if ((is_slot(p)) &&
                            (!has_methods(slot_value(p))))
                        return(p);
                    return(NULL);
                }

// Assembly:
pushq %rax
callq 0xb00b
cmpb $0x20, (%rax)
jne 0x85ac0
movq 0x10(%rax), %rcx
testb $0x40, 0x3(%rcx)
je 0x85ac2
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_i_s
static s7_pointer opt_set_p_i_s(opt_info *o)
                {
                    s7_pointer val;
                    oo_rc(o->sc, o, 3, 2);
                    val = slot_value(o->v[2].p);
                    if (is_mutable_integer(val))
                        val = make_integer(o->sc, integer(val));
                    slot_set_value(o->v[1].p, val);
                    return(val);
                }

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x85b88
leaq 0x8fdce(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x85bc6
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x85bac
callq 0x9c27
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_d_s
static s7_pointer opt_set_p_d_s(opt_info *o)
                {
                    s7_pointer val;
                    oo_rc(o->sc, o, 3, 2);
                    val = slot_value(o->v[2].p);
                    if (is_mutable_number(val))
                        val = make_real(o->sc, real(val));
                    slot_set_value(o->v[1].p, val);
                    return(val);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
testb $0x4, 0x3(%rax)
je 0x85dc7
movsd 0x8(%rax), %xmm0
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x85dac
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_d_f
static s7_pointer opt_set_p_d_f(opt_info *o)
                {
                    s7_pointer x;
                    oo_rc(o->sc, o, 6, 1);
                    o->sc->pc++;
                    x = make_real(o->sc, o->v[5].fd(o->v[4].o1));
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

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

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

// Assembly:
pushq %rbx
movq %rcx, %rbx
testq %rdx, %rdx
js 0x86078
cmpq %rdx, 0x8(%rsi)
jle 0x86078
movq %rbx, %rcx
callq 0x2ecba
jmp 0x860bc
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x8f8d6(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
testq %rdx, %rdx
leaq 0x939a2(%rip), %rdx     # 0x119a48
leaq 0x93993(%rip), %r8      # 0x119a40
cmovsq %rdx, %r8
movq (%r8), %r8
movq %rax, %rdx
callq 0xcb8f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_set_p_piip_direct
static s7_pointer typed_vector_set_p_piip_direct(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_pointer p)
                {
                    if ((i1 < 0) || (i2 < 0) ||
                            (i1 >= vector_dimension(v, 0)) ||
                            (i2 >= vector_dimension(v, 1)))
                        return(g_vector_set(sc, set_elist_4(sc, v, make_integer(sc, i1), make_integer(sc, i2), p)));
                    return(typed_vector_setter(sc, v, i2 + (i1 * vector_offset(v, 0)), p));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, %rax
orq %rdx, %rax
js 0x86123
movq 0x18(%r15), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %r13, (%rcx)
jle 0x86123
cmpq %r12, 0x8(%rcx)
jle 0x86123
movq 0x18(%rax), %rax
imulq (%rax), %r13
addq %r12, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ecba
leaq 0x8f826(%rip), %rdx     # 0x115950
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x86139
movq (%rdx,%r13,8), %rbp
jmp 0x86179
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x8615e
movq %r14, %rdi
movq %rdx, %rbp
callq 0x9c27
movq %rbp, %rdx
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbp
movq $0xb, (%rbp)
movq %r13, 0x8(%rbp)
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0x86188
movq (%rdx,%r12,8), %rax
jmp 0x861c1
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x861a7
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r12, 0x8(%rax)
movq 0x6f0(%r14), %rcx
movq %r15, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rbp, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rbx, 0x8(%rax)
movq 0x6f0(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x627c1
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: vector_set_p_piip_direct
static s7_pointer vector_set_p_piip_direct(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_pointer p)
                {
                    /* normal untyped vector, rank == 2 */
                    if ((i1 < 0) || (i2 < 0) ||
                            (i1 >= vector_dimension(v, 0)) ||
                            (i2 >= vector_dimension(v, 1)))
                        return(g_vector_set(sc, set_elist_4(sc, v, make_integer(sc, i1), make_integer(sc, i2), p)));
                    vector_element(v, i2 + (i1 * vector_offset(v, 0))) = p;
                    return(p);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rax
orq %rdx, %rax
js 0x86260
movq 0x18(%r14), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %r13, (%rcx)
jle 0x86260
cmpq %r12, 0x8(%rcx)
jle 0x86260
movq 0x18(%rax), %rax
imulq (%rax), %r13
shlq $0x3, %r13
addq 0x10(%r14), %r13
movq %rbx, (%r13,%r12,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8f6e9(%rip), %rdx     # 0x115950
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x86276
movq (%rdx,%r13,8), %rbp
jmp 0x862b6
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0x8629b
movq %r15, %rdi
movq %rdx, %rbp
callq 0x9c27
movq %rbp, %rdx
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rbp
movq $0xb, (%rbp)
movq %r13, 0x8(%rbp)
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0x862c5
movq (%rdx,%r12,8), %rax
jmp 0x862fe
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0x862e4
movq %r15, %rdi
callq 0x9c27
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r12, 0x8(%rax)
movq 0x6f0(%r15), %rcx
movq %r14, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rbp, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rbx, 0x8(%rax)
movq 0x6f0(%r15), %rsi
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x627c1
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_i_fo_add
static s7_pointer opt_set_p_i_fo_add(opt_info *o)
                {
                    s7_pointer x;
                    s7_int i;
                    oo_rc(o->sc, o, 4, 3);
                    i = integer(slot_value(o->v[2].p)) + integer(slot_value(o->v[3].p));
                    x = make_integer(o->sc, i);
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

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

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

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

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

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

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

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

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

// Assembly:
movq (%rdi), %rax
leaq -0x1754(%rip), %rcx     # 0x85894
cmpq %rcx, %rax
je 0x86ffa
leaq -0x1704(%rip), %rcx     # 0x858f0
cmpq %rcx, %rax
je 0x8704f
retq
leaq 0xe6(%rip), %rax        # 0x870e7
movq %rax, (%rdi)
movq 0x38(%rdi), %rax
leaq -0x871b(%rip), %rcx     # 0x7e8f4
cmpq %rcx, %rax
je 0x87058
leaq -0x7200(%rip), %rcx     # 0x7fe1b
cmpq %rcx, %rax
jne 0x86ff9
leaq 0x124(%rip), %rax       # 0x8714b
movq %rax, (%rdi)
movq 0x30(%rdi), %rax
leaq -0x1b1ec(%rip), %rcx    # 0x6be49
cmpq %rcx, %rax
je 0x87063
leaq -0x1b1f3(%rip), %rcx    # 0x6be4e
cmpq %rcx, %rax
jne 0x86ff9
leaq 0x18d(%rip), %rax       # 0x871da
jmp 0x8705f
leaq 0x1c2(%rip), %rax       # 0x87218
jmp 0x8705f
leaq 0x90(%rip), %rax        # 0x870ef
movq %rax, (%rdi)
retq
leaq 0x132(%rip), %rax       # 0x8719c
jmp 0x8705f
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_begin_p
static s7_pointer opt_begin_p(opt_info *o)
                {
                    opt_info *o1;
                    s7_int i, len;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(sc, o, 2, 0);
                    len = o->v[1].i - 1;
                    for (i = 0; i < len; i++)
                    {
                        o1 = sc->opts[++sc->pc];
                        o1->v[0].fp(o1);
                    }
                    o1 = sc->opts[++sc->pc];
                    return(o1->v[0].fp(o1));
                }

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
testb %al, %al
je 0x872f6
movl 0x8(%rbx), %eax
decl %eax
xorl %ebx, %ebx
testl %eax, %eax
cmovgl %eax, %ebx
incl %ebx
movslq 0x2258(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
decl %ebx
jne 0x872d5
jmp 0x87307
movl 0x18(%rbx), %eax
movl %eax, 0x2258(%r14)
movq 0x130(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_and_bb1
static bool opt_and_bb1(opt_info *o)
                {
                    oo_rc(o->sc, o, 8, 0);
                    if (o->v[7].fb(o))
                    {
                        opt_info *o1;
                        o->sc->pc += 2;
                        o1 = o->sc->opts[o->sc->pc];
                        return(o1->v[0].fb(o1));
                    }
                    o->sc->pc = o->v[4].i;
                    return(false);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq *0x38(%rdi)
testb %al, %al
je 0x8846c
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x2(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2270(%rax,%rcx,8), %rdi
popq %rbx
jmpq *(%rdi)
movl 0x20(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_and_any_b
static bool opt_and_any_b(opt_info *o)
                {
                    int32_t i;
                    oo_rc(o->sc, o, 3, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        if (!o1->v[0].fb(o1))
                        {
                            o->sc->pc = o->v[2].i;
                            return(false);
                        }
                    }
                    return(true);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %r14
movq 0x8(%rbx), %r15
incq %r14
cmpq %r14, %r15
jle 0x885ba
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
testb %al, %al
jne 0x8857e
movl 0x10(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
cmpq %r14, %r15
setle %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_or_any_b
static bool opt_or_any_b(opt_info *o)
                {
                    int32_t i;
                    oo_rc(o->sc, o, 3, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        if (o1->v[0].fb(o1))
                        {
                            o->sc->pc = o->v[2].i;
                            return(true);
                        }
                    }
                    return(false);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %r14
movq 0x8(%rbx), %r15
incq %r14
cmpq %r14, %r15
jle 0x8860e
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
testb %al, %al
je 0x885d2
movl 0x10(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
cmpq %r14, %r15
setg %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_cond_clause
static s7_pointer opt_cond_clause(opt_info *o)
                {
                    /* top->p1 gets result, top->i1 is end index, o->v[3].i is end of current clause, o->v[1].i = body len */
                    opt_info *o1;
                    o1 = o->sc->opts[++o->sc->pc];
                    if (o1->v[0].fb(o1))
                        return(case_value(o));
                    o->sc->pc = o->v[3].i;
                    return(o->sc->unspecified);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
testb %al, %al
je 0x88df6
movq %rbx, %rdi
popq %rbx
jmp 0x88edf
movl 0x18(%rbx), %eax
movq 0x68(%rbx), %rcx
movl %eax, 0x2258(%rcx)
movq 0x130(%rcx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_cond
static s7_pointer opt_cond(opt_info *o)
                {
                    oo_rc(o->sc, o, 3, 0);
                    o->v[2].p = o->sc->unspecified;
                    while (o->sc->pc < o->v[1].i)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        o1->v[0].fp(o1);
                    }
                    return(o->v[2].p);
                }

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x2(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2270(%r14,%rax,8), %rdi
callq *(%rdi)
testb %al, %al
je 0x88eb4
movl 0x2258(%r14), %eax
jmp 0x88eb7
movl 0x18(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
cltq
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movl 0x8(%rbx), %ecx
movl %ecx, 0x2258(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq