LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: d_v_ok
static bool d_v_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_v_t flt_func;
                    flt_func = s7_d_v_function(s_func);
                    if (flt_func)
                    {
                        s7_pointer sig;
                        sig = c_function_signature(s_func);
                        if ((is_pair(sig)) &&
                                (is_symbol(cadr(sig))) &&
                                (is_symbol(cadr(car_x))))           /* look for (oscil g) */
                        {
                            s7_pointer slot;
                            slot = opt_types_match(sc, cadr(sig), cadr(car_x));
                            if (slot)
                            {
                                opc->v[1].p = slot;
                                opc->v[5].obj = (void *)c_object_value(slot_value(slot));
                                opc->v[3].d_v_f = flt_func;
                                opc->v[0].fd = opt_d_v;
                                return(oo_set_type_1(opc, 6, 1 + (5 << 4), OO_V));
                            }}}
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0x9d4e3
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0x9d553
movq %rsi, %rbx
cmpl $0x0, (%rdx)
je 0x9d4e6
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x9d4d3
jmp 0x9d553
xorl %eax, %eax
retq
movq 0x8(%rdx), %r14
testq %r14, %r14
je 0x9d553
movq 0x38(%rax), %rax
cmpb $0x1, (%rax)
jne 0x9d553
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0xa, (%rsi)
jne 0x9d553
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
cmpb $0xa, (%rdx)
jne 0x9d553
callq 0xbacd7
testq %rax, %rax
je 0x9d553
movq %rax, 0x8(%rbx)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rbx)
movq %r14, 0x18(%rbx)
leaq 0x2ff1(%rip), %rax      # 0xa0528
movq %rax, (%rbx)
movabsq $0x100000006, %rax      # imm = 0x100000006
movq %rax, 0x60(%rbx)
movl $0x3, 0x70(%rbx)
movb $0x1, %al
jmp 0x9d555
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: d_p_ok
static bool d_p_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_p_t dpf;
                    int32_t start;
                    start = sc->pc;
                    dpf = s7_d_p_function(s_func);
                    if (dpf)
                    {
                        opc->v[3].d_p_f = dpf;
                        if (is_symbol(cadr(car_x)))
                        {
                            s7_pointer slot;
                            slot = opt_simple_symbol(sc, cadr(car_x));
                            if (slot)
                            {
                                opc->v[1].p = slot;
                                opc->v[0].fd = opt_d_p_s;
                                return(oo_set_type_1(opc, 4, 1, OO_P));
                            }
                            return(return_false(sc, car_x, __func__, __LINE__));
                        }
                        if (cell_optimize(sc, cdr(car_x)))
                        {
                            opc->v[0].fd = opt_d_p_f;
                            return(oo_set_type_0(opc, 4));
                        }
                        pc_fallback(sc, start);
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0x9d593
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x9d60f
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2258(%rdi), %ebp
cmpl $0x19, (%rax)
je 0x9d596
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x9d583
jmp 0x9d60f
xorl %eax, %eax
retq
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x9d60f
movq %rax, 0x18(%rbx)
movq 0x10(%rcx), %rsi
movq 0x8(%rsi), %rax
cmpb $0xa, (%rax)
jne 0x9d5e6
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0xa56a4
testq %rax, %rax
je 0x9d60f
movq %rax, 0x8(%rbx)
leaq 0x1dd09(%rip), %rax     # 0xbb2d5
movq %rax, (%rbx)
movabsq $0x100000004, %rax      # imm = 0x100000004
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
jmp 0x9d604
movq %r14, %rdi
callq 0xa2000
testb %al, %al
je 0x9d608
leaq 0x1dcea(%rip), %rax     # 0xbb2e3
movq %rax, (%rbx)
movq $0x4, 0x60(%rbx)
movb $0x1, %al
jmp 0x9d611
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: d_ip_ok
static bool d_ip_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_ip_t pfunc;
                    pfunc = s7_d_ip_function(s_func);
                    if ((pfunc) &&
                            (is_symbol(caddr(car_x))))
                    {
                        s7_pointer p;
                        p = opt_integer_symbol(sc, cadr(car_x));
                        if (p)
                        {
                            opc->v[3].d_ip_f = pfunc;
                            opc->v[1].p = p;
                            opc->v[2].p = symbol_to_slot(sc, caddr(car_x));
                            if (is_slot(opc->v[2].p))
                            {
                                /* (with-sound (:reverb jc-reverb) (fm-violin 0 .1 440 .4 :reverb-amount .5)) */
                                opc->v[0].fd = opt_d_ip_ss;
                                return(oo_set_type_2(opc, 4, 1, 2, OO_I, OO_P));
                            }}}
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0x9e32a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x9e3cf
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x8, (%rax)
je 0x9e32d
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x9e317
jmp 0x9e3cf
xorl %eax, %eax
retq
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x9e3cf
movq 0x10(%r15), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
cmpb $0xa, (%rcx)
jne 0x9e3cf
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0x9f8a2
testq %rax, %rax
je 0x9e3cf
movq %r12, 0x18(%rbx)
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%r14), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0x9e39e
jle 0x9e399
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0x9e38c
cmpq %rsi, %rdi
jne 0x9e3dd
movq (%rax,%rcx), %rsi
movq %rsi, 0x10(%rbx)
cmpb $0x20, (%rsi)
jne 0x9e3cf
leaq 0x1e3d4(%rip), %rax     # 0xbc786
movq %rax, (%rbx)
movabsq $0x200000004, %rax      # imm = 0x200000004
movq %rax, 0x60(%rbx)
movq $0x1, 0x70(%rbx)
movb $0x1, %al
jmp 0x9e3d1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0x9e39e
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x9e3fc
cmpq %rax, 0x8(%rsi)
je 0x9e3a2
movq 0x18(%rsi), %rsi
jmp 0x9e3eb
movq 0x10(%rdx), %rdx
jmp 0x9e3e2
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: d_vdd_ok
static bool d_vdd_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_vdd_t flt;
                    flt = s7_d_vdd_function(s_func);
                    if (flt)
                    {
                        s7_pointer sig;
                        opc->v[4].d_vdd_f = flt;
                        sig = c_function_signature(s_func);
                        if (is_pair(sig))
                        {
                            s7_pointer slot;
                            slot = opt_types_match(sc, cadr(sig), cadr(car_x));
                            if (slot)
                            {
                                int32_t start;
                                start = sc->pc;
                                if ((float_optimize(sc, cddr(car_x))) &&
                                        (float_optimize(sc, cdddr(car_x))))
                                {
                                    opc->v[1].p = slot;
                                    opc->v[5].obj = (void *)c_object_value(slot_value(slot));
                                    opc->v[0].fd = opt_d_vdd_ff;
                                    return(oo_set_type_1(opc, 6, 1 + (5 << 4), OO_V));
                                }
                                pc_fallback(sc, start);
                            }}}
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0x9eda2
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x9ee55
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, (%rax)
je 0x9eda5
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x9ed8f
jmp 0x9ee55
xorl %eax, %eax
retq
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x9ee55
movq %rax, 0x20(%rbx)
movq 0x8(%rdx), %rax
movq 0x38(%rax), %rax
cmpb $0x1, (%rax)
jne 0x9ee55
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0xbacd7
testq %rax, %rax
je 0x9ee55
movq %rax, %r12
movl 0x2258(%r14), %ebp
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x44f61
testb %al, %al
je 0x9ee4e
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x44f61
testb %al, %al
je 0x9ee4e
movq %r12, 0x8(%rbx)
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rbx)
leaq 0x1dd41(%rip), %rax     # 0xbcb73
movq %rax, (%rbx)
movabsq $0x100000006, %rax      # imm = 0x100000006
movq %rax, 0x60(%rbx)
movl $0x3, 0x70(%rbx)
movb $0x1, %al
jmp 0x9ee57
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: d_dddd_ok
static bool d_dddd_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_dddd_t f;
                    f = s7_d_dddd_function(s_func);
                    if (f)
                    {
                        if ((float_optimize(sc, cdr(car_x))) &&
                                (float_optimize(sc, cddr(car_x))) &&
                                (float_optimize(sc, cdddr(car_x))) &&
                                (float_optimize(sc, cddddr(car_x))))
                        {
                            opc->v[1].d_dddd_f = f;
                            opc->v[0].fd = opt_d_dddd_ffff;
                            return(oo_set_type_0(opc, 2));
                        }
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0x9f0c2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x9f140
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x10, (%rax)
je 0x9f0c5
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x9f0b2
jmp 0x9f140
xorl %eax, %eax
retq
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x9f140
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x44f61
testb %al, %al
je 0x9f140
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x44f61
testb %al, %al
je 0x9f140
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x44f61
testb %al, %al
je 0x9f140
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x44f61
testb %al, %al
je 0x9f140
movq %r12, 0x8(%rbx)
leaq 0x1dad1(%rip), %rax     # 0xbcc02
movq %rax, (%rbx)
movq $0x2, 0x60(%rbx)
movb $0x1, %al
jmp 0x9f142
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
cmpb $0x30, (%rdx)
jb 0x9f192
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x9f192
cmpl $0x7, (%rax)
je 0x9f16b
movq 0x10(%rax), %rax
jmp 0x9f15b
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x9f192
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rdx
cmpb $0xa, (%rdx)
jne 0x9f192
movq %rax, 0x20(%rsi)
movq 0x8(%rcx), %rax
cmpq 0xef8(%rdi), %rax
je 0x9f195
xorl %eax, %eax
retq
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %r8
movq 0x10(%r8), %r9
jmp 0x9f4af
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: d_add_any_ok
static bool d_add_any_ok(s7_scheme *sc, opt_info *opc, s7_pointer car_x, int32_t len)
                {
                    s7_pointer head;
                    int32_t start;
                    start = sc->pc;
                    head = car(car_x);
                    if ((head == sc->add_symbol) ||
                            (head == sc->multiply_symbol))
                    {
                        s7_pointer p;
                        int32_t cur_len;
                        for (cur_len = 0, p = cdr(car_x); is_pair(p); p = cdr(p), cur_len++)
                            if (!float_optimize(sc, p))
                                break;
                        if (is_null(p))
                        {
                            /* since 2|3|4-arg case is split out above, can cur_len ever be 2? */
                            opc->v[1].i = cur_len;
                            opc->v[0].fd = (head == sc->add_symbol) ? opt_d_add_any_f : opt_d_multiply_any_f;
                            return(oo_set_type_0(opc, 2));
                        }
                    }
                    else
                    {
                        if (head == sc->subtract_symbol)
                        {
                            s7_pointer p;
                            opc->v[1].i = (len - 1);
                            for (p = cdr(car_x); is_pair(p); p = cdr(p))
                                if (!float_optimize(sc, p))
                                    break;
                            if (is_null(p))
                            {
                                opc->v[0].fd = opt_d_subtract_any_f;
                                return(oo_set_type_0(opc, 2));
                            }
                        }
                    }
                    pc_fallback(sc, start);
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2258(%rdi), %ebp
movq 0x8(%rdx), %r12
cmpq 0xba8(%rdi), %r12
je 0x9f21e
cmpq 0x1358(%r14), %r12
je 0x9f21e
cmpq 0x1588(%r14), %r12
jne 0x9f253
decl %ecx
movslq %ecx, %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x9f209
movq %r14, %rdi
movq %r15, %rsi
callq 0x44f61
testb %al, %al
jne 0x9f1f0
cmpq 0x110(%r14), %r15
jne 0x9f253
leaq 0x1db68(%rip), %rax     # 0xbcd81
movq %rax, (%rbx)
jmp 0x9f27e
movq 0x10(%r15), %r15
xorl %r13d, %r13d
cmpb $0x1, (%r15)
jne 0x9f24a
movq %r14, %rdi
movq %r15, %rsi
callq 0x44f61
testb %al, %al
je 0x9f247
incl %r13d
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
je 0x9f22b
movl %r13d, %r13d
cmpq 0x110(%r14), %r15
je 0x9f25e
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
jmp 0x9f288
movq %r13, 0x8(%rbx)
cmpq 0xba8(%r14), %r12
leaq 0x1da45(%rip), %rax     # 0xbccb5
leaq 0x1da9f(%rip), %rcx     # 0xbcd16
cmoveq %rax, %rcx
movq %rcx, (%rbx)
movq $0x2, 0x60(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0xbce04
movq %rax, 0x10(%rbx)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x9f2fc
movq %rbx, %rdi
callq 0xa550
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 $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 0xfd85
movq 0x20(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9f3a3
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rsi), %rax
movl $0x18, %ecx
cmpq %rax, %rdi
je 0x9f386
jle 0x9f381
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rax
jl 0x9f374
cmpq %rax, %rdi
jne 0x9f3a6
movq (%rsi,%rcx), %rax
cmpb $0x20, (%rax)
jne 0x9f3a3
movq 0x10(%rax), %rcx
movzbl (%rcx), %ecx
leaq 0xab613(%rip), %rdx     # 0x14a9b0
cmpb $0x0, (%rcx,%rdx)
jne 0x9f3a5
xorl %eax, %eax
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0x9f386
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x9f3c5
cmpq %rsi, 0x8(%rax)
je 0x9f38a
movq 0x18(%rax), %rax
jmp 0x9f3b4
movq 0x10(%rdx), %rdx
jmp 0x9f3ab
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: opt_D_s
static s7_double opt_D_s(opt_info *o)
                {
                    s7_pointer x;
                    oo_rc(o->sc, o, 2, 1);
                    x = slot_value(o->v[1].p);
                    if (is_t_integer(x)) return((s7_double)(integer(x)));
                    return(s7_number_to_real(o->sc, x));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0x9f3ed
cvtsi2sdq 0x8(%rsi), %xmm0
retq
movq 0x68(%rdi), %rdi
leaq 0x6ac59(%rip), %rdx     # 0x10a051
jmp 0xd498
// File: /workspace/github_c_makefile_star2_O3/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 0x9f486
movsd %xmm0, 0x8(%rsp)
callq 0xa550
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_O3/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 0x9f8e3
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rsi), %rax
movl $0x18, %ecx
cmpq %rax, %rdi
je 0x9f8d1
jle 0x9f8cc
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rax
jl 0x9f8bf
cmpq %rax, %rdi
jne 0x9f8e6
movq (%rsi,%rcx), %rax
cmpb $0x20, (%rax)
jne 0x9f8e3
movq 0x10(%rax), %rcx
cmpb $0xb, (%rcx)
je 0x9f8e5
xorl %eax, %eax
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0x9f8d1
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x9f905
cmpq %rsi, 0x8(%rax)
je 0x9f8d5
movq 0x18(%rax), %rax
jmp 0x9f8f4
movq 0x10(%rdx), %rdx
jmp 0x9f8eb
// File: /workspace/github_c_makefile_star2_O3/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 0x9f956
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rsi), %rax
movl $0x18, %ecx
cmpq %rax, %rdi
je 0x9f944
jle 0x9f93f
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rax
jl 0x9f932
cmpq %rax, %rdi
jne 0x9f959
movq (%rsi,%rcx), %rax
cmpb $0x20, (%rax)
jne 0x9f956
movq 0x10(%rax), %rcx
cmpb $0xd, (%rcx)
je 0x9f958
xorl %eax, %eax
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0x9f944
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x9f978
cmpq %rsi, 0x8(%rax)
je 0x9f948
movq 0x18(%rax), %rax
jmp 0x9f967
movq 0x10(%rdx), %rdx
jmp 0x9f95e
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: i_iii_ok
static bool i_iii_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_i_iii_t ifunc;
                    ifunc = s7_i_iii_function(s_func);
                    if (ifunc)
                    {
                        int32_t start;
                        start = sc->pc;
                        if ((int_optimize(sc, cdr(car_x))) &&
                                (int_optimize(sc, cddr(car_x))) &&
                                (int_optimize(sc, cdddr(car_x))))
                        {
                            opc->v[3].i_iii_f = ifunc;
                            opc->v[0].fi = opt_i_iii_fff;
                            return(oo_set_type_0(opc, 4));
                        }
                        pc_fallback(sc, start);
                        return(return_false(sc, car_x, __func__, __LINE__));
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0xa1183
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa11f3
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x15, (%rax)
je 0xa1186
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa1173
jmp 0xa11f3
xorl %eax, %eax
retq
movq 0x8(%rax), %r12
testq %r12, %r12
je 0xa11f3
movl 0x2258(%r14), %ebp
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x9fbc8
testb %al, %al
je 0xa11ec
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x9fbc8
testb %al, %al
je 0xa11ec
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x9fbc8
testb %al, %al
je 0xa11ec
movq %r12, 0x18(%rbx)
leaq 0x19b99(%rip), %rax     # 0xbad76
movq %rax, (%rbx)
movq $0x4, 0x60(%rbx)
movb $0x1, %al
jmp 0xa11f5
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
cmpb $0x30, (%rdx)
jb 0xa1526
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa1526
movq %rsi, %r10
cmpl $0x18, (%rax)
je 0xa1473
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa1460
jmp 0xa1526
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xa1526
movq 0x10(%rcx), %r8
movq 0x8(%r8), %rax
cmpb $0xa, (%rax)
jne 0xa1526
movq 0x8(%rcx), %rsi
cmpq 0xfb0(%rdi), %rsi
je 0xa152a
cmpq 0xc38(%rdi), %rsi
je 0xa1531
movq 0x8(%rdi), %r8
movq 0x18(%r8), %r11
movq 0x20(%rax), %r9
movl $0x18, %esi
cmpq %r9, %r11
je 0xa14d9
jle 0xa14d4
movq 0x10(%r8), %r8
movq 0x18(%r8), %r11
cmpq %r11, %r9
jl 0xa14c7
cmpq %r9, %r11
jne 0xa1553
movq (%rax,%rsi), %r9
cmpb $0x20, (%r9)
jne 0xa1526
movq 0x10(%r9), %rax
cmpb $0x16, (%rax)
jne 0xa1526
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa1526
cmpq $0x3, 0x10(%rax)
jne 0xa1526
movq %rdx, 0x28(%r10)
movq %r9, 0x8(%r10)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %r8
movq 0x10(%r8), %r9
movq %r10, %rsi
movl $0x4, %edx
popq %rax
jmp 0xa1b9c
xorl %eax, %eax
popq %rcx
retq
movl $0x4, %esi
jmp 0xa1536
movl $0xa, %esi
movq 0x10(%r8), %r8
movq 0x10(%r8), %r9
movq 0x10(%r9), %rcx
movq %rcx, (%rsp)
movq %r10, %rdx
movq %rax, %rcx
callq 0xa17a5
jmp 0xa1528
movl $0x10, %esi
cmpb $0x1c, (%r8)
jne 0xa14d9
movq 0x8(%r8), %r9
testq %r9, %r9
je 0xa157b
cmpq %rax, 0x8(%r9)
je 0xa14dd
movq 0x18(%r9), %r9
jmp 0xa1566
movq 0x10(%r8), %r8
jmp 0xa1558
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: i_add_any_ok
static bool i_add_any_ok(s7_scheme *sc, opt_info *opc, s7_pointer car_x)
                {
                    s7_pointer p, head;
                    int32_t cur_len, start;
                    start = sc->pc;
                    head = car(car_x);
                    for (cur_len = 0, p = cdr(car_x); is_pair(p); p = cdr(p), cur_len++)
                        if (!int_optimize(sc, p))
                            break;
                    if (is_null(p))
                    {
                        opc->v[1].i = cur_len;
                        if (cur_len == 2)
                            opc->v[0].fi = (head == sc->add_symbol) ? opt_i_add2 : opt_i_mul2;
                        else
                        {
                            if (cur_len == 3)
                                opc->v[0].fi = (head == sc->add_symbol) ? opt_i_add3 : opt_i_mul3;
                            else
                            {
                                if (cur_len == 4)
                                    opc->v[0].fi = (head == sc->add_symbol) ? opt_i_add4 : opt_i_mul4;
                                else opc->v[0].fi = (head == sc->add_symbol) ? opt_i_add_any_f : opt_i_multiply_any_f;
                            }
                        }
                        /* all v[1].i = cur_len */
                        return(oo_set_type_0(opc, 2));
                    }
                    pc_fallback(sc, start);
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl 0x2258(%rdi), %r13d
movq 0x8(%rdx), %r12
movq 0x10(%rdx), %rbx
xorl %ebp, %ebp
cmpb $0x1, (%rbx)
jne 0xa15c4
xorl %ebp, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9fbc8
testb %al, %al
je 0xa15c4
incl %ebp
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0xa15aa
movq 0x110(%r15), %rax
cmpq %rax, %rbx
je 0xa15d9
movl %r13d, 0x2258(%r15)
jmp 0xa164e
movl %ebp, %ecx
movq %rcx, 0x8(%r14)
movq 0xba8(%r15), %rcx
cmpl $0x4, %ebp
je 0xa161b
cmpl $0x3, %ebp
je 0xa1608
cmpl $0x2, %ebp
jne 0xa162e
cmpq %rcx, %r12
leaq 0x19803(%rip), %rdx     # 0xbae02
leaq 0x1984a(%rip), %rcx     # 0xbae50
jmp 0xa163f
cmpq %rcx, %r12
leaq 0x1988d(%rip), %rdx     # 0xbae9f
leaq 0x198f5(%rip), %rcx     # 0xbaf0e
jmp 0xa163f
cmpq %rcx, %r12
leaq 0x1995a(%rip), %rdx     # 0xbaf7f
leaq 0x199e4(%rip), %rcx     # 0xbb010
jmp 0xa163f
cmpq %rcx, %r12
leaq 0x19a6c(%rip), %rdx     # 0xbb0a4
leaq 0x19ab3(%rip), %rcx     # 0xbb0f2
cmoveq %rdx, %rcx
movq %rcx, (%r14)
movq $0x2, 0x60(%r14)
cmpq %rax, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: set_i_i_f_combinable
static bool set_i_i_f_combinable(s7_scheme *sc, opt_info *opc)
                {
                    if ((sc->pc > 1) &&
                            (opc == sc->opts[sc->pc - 2]))
                    {
                        opt_info *o1;
                        o1 = sc->opts[sc->pc - 1];
                        if (o1->v[0].fi == opt_i_ii_sc_add)
                        {
                            /* opc->v[4].i_ii_f = o1->v[3].i_ii_f; */
                            opc->v[3].p = o1->v[1].p;
                            opc->v[2].i = o1->v[2].i;
                            opc->v[0].fi = opt_set_i_i_fo;
                            backup_pc(sc);
                            return(oo_set_type_2(opc, 5, 1, 3, OO_I, OO_I)); /* ii_sc v[1].p is a slot */
                        }
                    }
                    return(return_false(sc, NULL, __func__, __LINE__));
                }

// Assembly:
movl 0x2258(%rdi), %eax
cmpl $0x2, %eax
jl 0xa16a3
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xa16a3
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq 0x370(%rip), %rcx       # 0xa1a0e
cmpq %rcx, (%rax)
je 0xa16a6
xorl %eax, %eax
retq
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsi)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
leaq 0x362(%rip), %rax       # 0xa1a1f
movq %rax, (%rsi)
decl 0x2258(%rdi)
movabsq $0x200000005, %rax      # imm = 0x200000005
movq %rax, 0x60(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x70(%rsi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa1754
leaq 0xa5202(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xa1792
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa1778
callq 0xa550
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_O3/BernardTatin[P]s7sh/s7.c
// Function: p_ok
static bool p_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_p_t func;
                    func = s7_p_function(s_func);
                    if (func)
                    {
                        opc->v[1].p_f = func;
                        opc->v[0].fp = opt_p_f;
                        return(oo_set_type_0(opc, 2));
                    }
                    if ((is_safe_procedure(s_func)) &&
                            (c_function_required_args(s_func) == 0))
                    {
                        opc->v[1].call = cf_call(sc, car_x, s_func, 0);
                        opc->v[0].fp = opt_p_call;
                        return(oo_set_type_0(opc, 2));
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x30, (%rdx)
jb 0xa2fe4
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa2fe4
cmpl $0x23, (%rax)
je 0xa2fd2
movq 0x10(%rax), %rax
jmp 0xa2fc2
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xa2fe4
leaq 0xb66e(%rip), %rcx      # 0xae650
jmp 0xa3030
testb $0x20, 0x2(%rdx)
je 0xa2ff1
cmpq $0x0, 0x18(%rdx)
je 0xa2ff5
xorl %eax, %eax
jmp 0xa3041
cmpw $0x801, (%rcx)          # imm = 0x801
jne 0xa3010
movzwl 0x4(%rcx), %eax
leal -0x17f(%rax), %esi
cmpl $0x7, %esi
jb 0xa3010
cmpl $0x4, %eax
jae 0xa3043
movq 0x8(%rdx), %rax
movq %rdx, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq *0x48(%rax)
movq %rax, %rcx
addq $0x10, %rcx
movq (%rcx), %rax
leaq 0xb62a(%rip), %rcx      # 0xae65a
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq $0x2, 0x60(%rbx)
movb $0x1, %al
popq %rbx
retq
addq $0x20, %rcx
jmp 0xa3026
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: p_i_ok
static bool p_i_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x, int32_t pstart)
                {
                    s7_p_i_t ifunc;
                    ifunc = s7_p_i_function(s_func);
                    if (ifunc)
                    {
                        s7_pointer p;
                        p = opt_integer_symbol(sc, cadr(car_x));
                        if (p)
                        {
                            opc->v[1].p = p;
                            opc->v[2].p_i_f = ifunc;
                            opc->v[0].fp = opt_p_i_s;
                            return(oo_set_type_1(opc, 3, 1, OO_I));
                        }
                        if (int_optimize(sc, cdr(car_x)))
                        {
                            opc->v[2].p_i_f = ifunc;
                            opc->v[0].fp = opt_p_i_f;
                            opc->v[3].o1 = sc->opts[pstart];
                            opc->v[4].fi = sc->opts[pstart]->v[0].fi;
                            return(oo_set_type_0(opc, 5));
                        }
                    }
                    pc_fallback(sc, pstart);
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rdi, %r14
cmpb $0x30, (%rdx)
jb 0xa310d
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa310d
movq %rsi, %rbx
cmpl $0x33, (%rax)
je 0xa3087
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa3074
jmp 0xa310d
movq 0x8(%rax), %r12
testq %r12, %r12
je 0xa310d
movq 0x10(%rcx), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x9f8a2
testq %rax, %rax
je 0xa30ce
movq %rax, 0x8(%rbx)
movq %r12, 0x10(%rbx)
leaq 0xb5b7(%rip), %rax      # 0xae66b
movq %rax, (%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%rbx)
movl $0x1, 0x70(%rbx)
jmp 0xa3109
movq %r14, %rdi
movq %r15, %rsi
callq 0x9fbc8
testb %al, %al
je 0xa310d
movq %r12, 0x10(%rbx)
leaq 0xb599(%rip), %rax      # 0xae681
movq %rax, (%rbx)
movslq %ebp, %rax
movq 0x2260(%r14,%rax,8), %rax
movq %rax, 0x18(%rbx)
movq (%rax), %rax
movq %rax, 0x20(%rbx)
movq $0x5, 0x60(%rbx)
movb $0x1, %al
jmp 0xa3116
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: p_d_ok
static bool p_d_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x, int32_t pstart)
                {
                    s7_p_d_t ifunc;
                    ifunc = s7_p_d_function(s_func);
                    if (ifunc)
                    {
                        s7_pointer p;
                        p = opt_float_symbol(sc, cadr(car_x));
                        if (p)
                        {
                            opc->v[1].p = p;
                            opc->v[2].p_d_f = ifunc;
                            opc->v[0].fp = opt_p_d_s;
                            return(oo_set_type_1(opc, 3, 1, OO_R));
                        }
                        if ((is_number(cadr(car_x))) && (!is_float(cadr(car_x))))
                            return(return_false(sc, car_x, __func__, __LINE__));
                        if (float_optimize(sc, cdr(car_x)))
                        {
                            opc->v[2].p_d_f = ifunc;
                            opc->v[0].fp = opt_p_d_f;
                            return(oo_set_type_0(opc, 3));
                        }
                    }
                    pc_fallback(sc, pstart);
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdi, %r14
cmpb $0x30, (%rdx)
jb 0xa31ef
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa31ef
movq %rsi, %rbx
cmpl $0x26, (%rax)
je 0xa3160
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa314d
jmp 0xa31ef
movq 0x8(%rax), %r13
testq %r13, %r13
je 0xa31ef
movq 0x10(%rcx), %r15
movq 0x8(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x9f915
testq %rax, %rax
je 0xa31b0
movq %rax, 0x8(%rbx)
movq %r13, 0x10(%rbx)
leaq 0xb51b(%rip), %rax      # 0xae6af
movq %rax, (%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%rbx)
movl $0x7, 0x70(%rbx)
movb $0x1, %al
jmp 0xa31f8
movzbl (%r12), %eax
cmpq $0xd, %rax
je 0xa31c8
leaq 0xa77ae(%rip), %rcx     # 0x14a970
cmpb $0x0, (%rax,%rcx)
jne 0xa31f6
movq %r14, %rdi
movq %r15, %rsi
callq 0x44f61
testb %al, %al
je 0xa31ef
movq %r13, 0x10(%rbx)
leaq 0xb50e(%rip), %rax      # 0xae6f0
movq %rax, (%rbx)
movq $0x3, 0x60(%rbx)
jmp 0xa31ac
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: p_dd_ok
static bool p_dd_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x, int32_t pstart)
                {
                    s7_p_dd_t ifunc;
                    ifunc = s7_p_dd_function(s_func);
                    if (ifunc)
                    {
                        s7_pointer arg1, arg2, slot;
                        arg1 = cadr(car_x);
                        arg2 = caddr(car_x);
                        if (is_float(arg2))
                        {
                            slot = opt_real_symbol(sc, arg1);
                            if (slot)
                            {
                                opc->v[2].x = real(arg2);
                                opc->v[1].p = slot;
                                opc->v[3].p_dd_f = ifunc;
                                opc->v[0].fp = opt_p_dd_sc;
                                return(oo_set_type_1(opc, 4, 1, OO_R));
                            }
                        }
                        if (is_float(arg1))
                        {
                            slot = opt_real_symbol(sc, arg2);
                            if (slot)
                            {
                                opc->v[2].x = real(arg1);
                                opc->v[1].p = slot;
                                opc->v[3].p_dd_f = ifunc;
                                opc->v[0].fp = opt_p_dd_cs;
                                return(oo_set_type_1(opc, 4, 1, OO_R));
                            }
                        }
                    }
                    pc_fallback(sc, pstart);
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdi, %r14
cmpb $0x30, (%rdx)
jb 0xa3d0d
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa3d0d
movq %rsi, %rbx
cmpl $0x27, (%rax)
je 0xa3c70
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa3c5d
jmp 0xa3d0d
movq 0x8(%rax), %r13
testq %r13, %r13
je 0xa3d0d
movq 0x10(%rcx), %rax
movq 0x8(%rax), %r15
movq 0x10(%rax), %rax
movq 0x8(%rax), %r12
cmpb $0xd, (%r12)
jne 0xa3cc1
movq %r14, %rdi
movq %r15, %rsi
callq 0x9f357
testq %rax, %rax
je 0xa3cc1
movsd 0x8(%r12), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r13, 0x18(%rbx)
leaq 0xafab(%rip), %rax      # 0xaec6a
jmp 0xa3cf1
cmpb $0xd, (%r15)
jne 0xa3d0d
movq %r14, %rdi
movq %r12, %rsi
callq 0x9f357
testq %rax, %rax
je 0xa3d0d
movsd 0x8(%r15), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r13, 0x18(%rbx)
leaq 0xafc1(%rip), %rax      # 0xaecb2
movq %rax, (%rbx)
movabsq $0x100000004, %rax      # imm = 0x100000004
movq %rax, 0x60(%rbx)
movl $0x7, 0x70(%rbx)
movb $0x1, %al
jmp 0xa3d16
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: p_ppi_ok
static bool p_ppi_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_p_ppi_t ifunc;
                    ifunc = s7_p_ppi_function(s_func);
                    if (ifunc)
                    {
                        int32_t start;
                        start = sc->pc;
                        opc->v[3].p_ppi_f = ifunc;
                        if ((s7_is_character(cadr(car_x))) &&
                                (is_symbol(caddr(car_x))) &&
                                (int_optimize(sc, cdddr(car_x))))
                        {
                            s7_pointer slot;
                            slot = opt_simple_symbol(sc, caddr(car_x));
                            if (slot)
                            {
                                opc->v[2].p = cadr(car_x);
                                opc->v[1].p = slot;
                                opc->v[0].fp = opt_p_ppi_psf;
                                opc->v[4].o1 = sc->opts[start];
                                opc->v[5].fi = sc->opts[start]->v[0].fi;
                                return(oo_set_type_1(opc, 6, 1, OO_P));
                            }
                        }
                        pc_fallback(sc, start);
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0xa4af0
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xa4b9b
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x32, (%rax)
je 0xa4af3
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa4add
jmp 0xa4b9b
xorl %eax, %eax
retq
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xa4b9b
movl 0x2258(%r14), %ebp
movq %rax, 0x18(%rbx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
cmpb $0x8, (%rcx)
jne 0xa4b94
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
cmpb $0xa, (%rcx)
jne 0xa4b94
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x9fbc8
testb %al, %al
je 0xa4b94
movq 0x10(%r15), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq 0x8(%r14), %rdi
callq 0xa56a4
testq %rax, %rax
je 0xa4b94
movslq %ebp, %rcx
movq 0x8(%r15), %rdx
movq %rdx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
leaq 0xa611(%rip), %rax      # 0xaf176
movq %rax, (%rbx)
movq 0x2260(%r14,%rcx,8), %rax
movq %rax, 0x20(%rbx)
movq (%rax), %rax
movq %rax, 0x28(%rbx)
movabsq $0x100000006, %rax      # imm = 0x100000006
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
movb $0x1, %al
jmp 0xa4b9d
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: p_call_any_ok
static bool p_call_any_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x, int32_t len)
                {
                    if ((is_safe_procedure(s_func)) &&
                            (c_function_required_args(s_func) <= (len - 1)) &&
                            (c_function_all_args(s_func) >= (len - 1)))
                    {
                        s7_pointer p;      /* (vector-set! v k i 2) gets here */
                        opc->v[1].i = (len - 1);
                        for (p = cdr(car_x); is_pair(p); p = cdr(p))
                            if (!cell_optimize(sc, p))
                                break;
                        if (is_null(p))
                        {
                            opc->v[0].fp = opt_p_call_any;
                            opc->v[2].call = cf_call(sc, car_x, s_func, len - 1);
                            return(oo_set_type_0(opc, 3));
                        }
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
testb $0x20, 0x2(%rdx)
jne 0xa5582
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdx, %r15
decl %ebp
movslq %ebp, %rax
cmpq %rax, 0x18(%rdx)
jg 0xa55d8
cmpq %rax, 0x28(%r15)
jl 0xa55d8
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq %rax, 0x8(%rsi)
movq %rcx, %r13
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
jne 0xa55ce
movq %r12, %rdi
movq %r13, %rsi
callq 0xa2000
testb %al, %al
jne 0xa55b4
cmpq 0x110(%r12), %r13
je 0xa55e9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8eb3(%rip), %rax      # 0xae4a3
movq %rax, (%rbx)
cmpw $0x801, (%r14)          # imm = 0x801
jne 0xa5610
movzwl 0x4(%r14), %eax
leal -0x17f(%rax), %ecx
cmpl $0x7, %ecx
jb 0xa5610
cmpl $0x4, %eax
jae 0xa563f
movq 0x8(%r15), %rax
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
callq *0x48(%rax)
movq %rax, %r14
addq $0x10, %r14
movq (%r14), %rax
movq %rax, 0x10(%rbx)
movq $0x3, 0x60(%rbx)
movb $0x1, %al
jmp 0xa55da
addq $0x20, %r14
jmp 0xa562c