LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xa6417
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rsi), %rax
movl $0x18, %ecx
cmpq %rax, %rdi
je 0xa6405
jle 0xa63c9
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rax
jl 0xa63bc
cmpq %rax, %rdi
je 0xa6405
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xa6405
movq 0x8(%rdx), %rax
testq %rax, %rax
sete %r8b
je 0xa63f1
cmpq %rsi, 0x8(%rax)
je 0xa63f4
movq 0x18(%rax), %rax
jmp 0xa63dc
movq %rdi, %rax
testb %r8b, %r8b
je 0xa6409
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rax, %rdi
je 0xa63d8
movq (%rsi,%rcx), %rax
cmpb $0x20, (%rax)
jne 0xa6417
movq 0x10(%rax), %rcx
cmpb $0xb, (%rcx)
je 0xa6419
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa649c
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rsi), %rax
movl $0x18, %ecx
cmpq %rax, %rdi
je 0xa648a
jle 0xa644e
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rax
jl 0xa6441
cmpq %rax, %rdi
je 0xa648a
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xa648a
movq 0x8(%rdx), %rax
testq %rax, %rax
sete %r8b
je 0xa6476
cmpq %rsi, 0x8(%rax)
je 0xa6479
movq 0x18(%rax), %rax
jmp 0xa6461
movq %rdi, %rax
testb %r8b, %r8b
je 0xa648e
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rax, %rdi
je 0xa645d
movq (%rsi,%rcx), %rax
cmpb $0x20, (%rax)
jne 0xa649c
movq 0x10(%rax), %rcx
cmpb $0xd, (%rcx)
je 0xa649e
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_7pid_sff
static s7_double opt_d_7pid_sff(opt_info *o)
                {
                    opt_info *o1;
                    s7_int pos;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    pos = o1->v[0].fi(o1);
                    o1 = sc->opts[++sc->pc];
                    oo_rc(sc, o, 5, 1);
                    return(o->v[4].d_7pid_f(sc, slot_value(o->v[1].p), pos, o1->v[0].fd(o1)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
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)
movq %rax, %r15
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movq 0x8(%rbx), %rax
movq 0x20(%rbx), %r12
movq 0x10(%rax), %rbx
callq *(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_7piid_sfff
static s7_double opt_d_7piid_sfff(opt_info *o)
                {
                    opt_info *o1;
                    s7_int i1, i2;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    i1 = o1->v[0].fi(o1);
                    o1 = sc->opts[++sc->pc];
                    i2 = o1->v[0].fi(o1);
                    o1 = sc->opts[++sc->pc];
                    oo_rc(sc, o, 6, 1);
                    return(o->v[5].d_7piid_f(sc, slot_value(o->v[1].p), i1, i2, o1->v[0].fd(o1)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rbx
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq %rax, %r15
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq %rax, %r12
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
movq 0x8(%r14), %rax
movq 0x28(%r14), %r13
movq 0x10(%rax), %r14
callq *(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_7pid_ss_ss
static s7_double opt_d_7pid_ss_ss(opt_info *o)
                {
                    oo_rc(o->sc, o, 7, 4);
                    return(o->v[4].d_7pid_f(o->sc, slot_value(o->v[1].p),
                                integer(slot_value(o->v[2].p)),
                                o->v[3].d_7pi_f(o->sc, slot_value(o->v[5].p),
                                    integer(slot_value(o->v[6].p)))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rax
movq 0x20(%rdi), %r12
movq 0x68(%rdi), %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
movq 0x10(%rcx), %r14
movq 0x10(%rdx), %rcx
movq 0x8(%rcx), %r15
movq 0x28(%rdi), %rcx
movq 0x10(%rcx), %rsi
movq 0x30(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq %rbx, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_7pid_ssfo
static s7_double opt_d_7pid_ssfo(opt_info *o)
                {
                    s7_pointer fv;
                    fv = slot_value(o->v[1].p);
                    oo_rc(o->sc, o, 9, 4);
                    return(o->v[4].d_7pid_f(o->sc, fv, integer(slot_value(o->v[2].p)),
                                o->v[6].d_dd_f(o->v[5].d_7pi_f(o->sc, fv, integer(slot_value(o->v[3].p))), real(slot_value(o->v[8].p)))));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x10(%rax), %r14
movq 0x20(%rdi), %rbp
movq 0x68(%rdi), %r15
movq 0x10(%rcx), %rax
movq 0x8(%rax), %r12
movq 0x30(%rdi), %r13
movq 0x18(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rbx)
movq 0x40(%rbx), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm1
callq *%r13
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_d_7pid_ssfo_fv
static s7_double opt_d_7pid_ssfo_fv(opt_info *o)
                {
                    s7_double val;
                    s7_double *els;
                    els = float_vector_floats(slot_value(o->v[1].p));
                    val = o->v[6].d_dd_f(els[integer(slot_value(o->v[3].p))], real(slot_value(o->v[8].p)));
                    els[integer(slot_value(o->v[2].p))] = val;
                    oo_rc(o->sc, o, 7, 4);
                    return(val);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x10(%rax), %rax
movq 0x10(%rax), %r14
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
movsd (%r14,%rax,8), %xmm0
movq 0x40(%rdi), %rax
movq 0x10(%rax), %rax
movsd 0x8(%rax), %xmm1
callq *0x30(%rdi)
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movsd %xmm0, (%r14,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x47b22
testq %rax, %rax
je 0xa7d0a
movq %rax, %r15
movl 0x2258(%r14), %ebp
movq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0xa66f0
testb %al, %al
je 0xa7d03
movq 0x10(%r12), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa66f0
testb %al, %al
je 0xa7d03
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa66f0
testb %al, %al
je 0xa7d03
movq %r15, 0x18(%rbx)
leaq 0x1ae19(%rip), %rax     # 0xc2b0d
movq %rax, (%rbx)
movq $0x4, 0x60(%rbx)
movb $0x1, %al
jmp 0xa7d0c
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa810e
xorl %ebp, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa66f0
testb %al, %al
je 0xa810e
incl %ebp
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0xa80f4
movq 0x110(%r15), %rax
cmpq %rax, %rbx
je 0xa8123
movl %r13d, 0x2258(%r15)
jmp 0xa8198
movl %ebp, %ecx
movq %rcx, 0x8(%r14)
movq 0xba8(%r15), %rcx
cmpl $0x4, %ebp
je 0xa8165
cmpl $0x3, %ebp
je 0xa8152
cmpl $0x2, %ebp
jne 0xa8178
cmpq %rcx, %r12
leaq 0x1aa50(%rip), %rdx     # 0xc2b99
leaq 0x1aa97(%rip), %rcx     # 0xc2be7
jmp 0xa8189
cmpq %rcx, %r12
leaq 0x1aada(%rip), %rdx     # 0xc2c36
leaq 0x1ab42(%rip), %rcx     # 0xc2ca5
jmp 0xa8189
cmpq %rcx, %r12
leaq 0x1aba7(%rip), %rdx     # 0xc2d16
leaq 0x1ac31(%rip), %rcx     # 0xc2da7
jmp 0xa8189
cmpq %rcx, %r12
leaq 0x1acb9(%rip), %rdx     # 0xc2e3b
leaq 0x1ad00(%rip), %rcx     # 0xc2e89
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_O1/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 0xa81ed
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xa81ed
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq 0x3a6(%rip), %rcx       # 0xa858e
cmpq %rcx, (%rax)
je 0xa81f0
xorl %eax, %eax
retq
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsi)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
leaq 0x398(%rip), %rax       # 0xa859f
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_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_set_i_i_fm
static s7_int opt_set_i_i_fm(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);
                    integer(slot_value(o->v[1].p)) = x;
                    return(x);
                }

// 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)
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa829e
leaq 0xa66b8(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0xa82dc
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa82b7
callq 0xb389
movq 0x68(%rbx), %rax
movq 0x90(%rax), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rax)
movq -0x8(%rcx), %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_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_i_7pii_sff
static s7_int opt_i_7pii_sff(opt_info *o)
                {
                    opt_info *o1, *o2;
                    s7_int i1;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    i1 = o1->v[0].fi(o1);
                    o2 = sc->opts[++sc->pc];
                    oo_rc(sc, o, 4, 1);
                    return(o->v[3].i_7pii_f(sc, slot_value(o->v[1].p), i1, o2->v[0].fi(o2)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
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)
movq %rax, %r15
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %r12
movq 0x10(%rax), %rbx
callq *(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 0xa9c1b
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rsi
testq %rsi, %rsi
sete %r8b
je 0xa9c16
cmpl $0x23, (%rsi)
je 0xa9c0d
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
sete %r8b
je 0xa9c16
cmpl $0x23, (%rsi)
jne 0xa9bfb
movq 0x8(%rsi), %rax
xorl %r8d, %r8d
jmp 0xa9c16
testb %r8b, %r8b
je 0xa9c1d
xorl %eax, %eax
testq %rax, %rax
je 0xa9c3c
leaq 0xbd15(%rip), %rcx      # 0xb593e
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq $0x2, 0x60(%rbx)
movb $0x1, %al
jmp 0xa9c4b
testb $0x20, 0x2(%rdx)
je 0xa9c49
cmpq $0x0, 0x18(%rdx)
je 0xa9c4d
xorl %eax, %eax
popq %rbx
retq
cmpw $0x801, (%rcx)          # imm = 0x801
jne 0xa9c68
movzwl 0x4(%rcx), %eax
leal -0x17f(%rax), %esi
cmpl $0x7, %esi
jb 0xa9c68
cmpl $0x4, %eax
jae 0xa9c8a
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 0xbcc0(%rip), %rcx      # 0xb5948
jmp 0xa9c29
addq $0x20, %rcx
jmp 0xa9c7e
// File: /workspace/github_c_makefile_star2_O1/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 %rsi, %rbx
movq %rdi, %r14
cmpb $0x30, (%rdx)
jb 0xa9cd8
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
sete %dl
je 0xa9cd4
cmpl $0x33, (%rax)
je 0xa9ccc
movq 0x10(%rax), %rax
testq %rax, %rax
sete %dl
je 0xa9cd4
cmpl $0x33, (%rax)
jne 0xa9cbb
movq 0x8(%rax), %r12
xorl %edx, %edx
jmp 0xa9cd4
testb %dl, %dl
je 0xa9cdb
xorl %r12d, %r12d
testq %r12, %r12
je 0xa9d69
movq 0x10(%rcx), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xa639f
testq %rax, %rax
je 0xa9d22
movq %rax, 0x8(%rbx)
movq %r12, 0x10(%rbx)
leaq 0xbc51(%rip), %rax      # 0xb5959
movq %rax, (%rbx)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%rbx)
movl $0x1, 0x70(%rbx)
jmp 0xa9d65
movq %r14, %rdi
movq %r15, %rsi
callq 0xa66f0
testb %al, %al
je 0xa9d69
movq %r12, 0x10(%rbx)
leaq 0xbc33(%rip), %rax      # 0xb596f
movq %rax, (%rbx)
movslq %ebp, %rax
movq 0x2260(%r14,%rax,8), %rcx
movq %rcx, 0x18(%rbx)
movq 0x2260(%r14,%rax,8), %rax
movq (%rax), %rax
movq %rax, 0x20(%rbx)
movq $0x5, 0x60(%rbx)
movb $0x1, %al
jmp 0xa9d72
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ebx
movq %rcx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x47af5
testq %rax, %rax
je 0xa9e05
movq %rax, %r12
movq 0x10(%r13), %r13
movq 0x8(%r13), %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0xa6424
testq %rax, %rax
je 0xa9de6
movq %rax, 0x8(%r15)
movq %r12, 0x10(%r15)
leaq 0xbbd4(%rip), %rax      # 0xb599d
movq %rax, (%r15)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x60(%r15)
movl $0x7, 0x70(%r15)
movb $0x1, %al
jmp 0xa9dff
movzbl (%rbp), %eax
cmpq $0xd, %rax
je 0xa9e1f
leaq 0xa8b79(%rip), %rcx     # 0x152970
cmpb $0x0, (%rax,%rcx)
je 0xa9e1f
xorl %eax, %eax
xorl %ecx, %ecx
testb %cl, %cl
je 0xa9e0e
movl %ebx, 0x2258(%r14)
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r13, %rsi
callq 0x47b96
testb %al, %al
je 0xa9e46
movq %r12, 0x10(%r15)
leaq 0xbba5(%rip), %rax      # 0xb59de
movq %rax, (%r15)
movq $0x3, 0x60(%r15)
jmp 0xa9de2
movb $0x1, %cl
jmp 0xa9e01
// File: /workspace/github_c_makefile_star2_O1/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 %rcx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0xb5fe0
testq %rax, %rax
je 0xaa861
movq %rax, %r14
movq 0x10(%r12), %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %rax
movq 0x8(%rax), %r13
cmpb $0xd, (%r13)
jne 0xaa813
movq %r15, %rdi
movq %r12, %rsi
callq 0xa5df6
testq %rax, %rax
je 0xaa813
movsd 0x8(%r13), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, 0x18(%rbx)
leaq 0xb7fc(%rip), %rax      # 0xb600d
jmp 0xaa845
cmpb $0xd, (%r12)
jne 0xaa861
movq %r15, %rdi
movq %r13, %rsi
callq 0xa5df6
testq %rax, %rax
je 0xaa861
movsd 0x8(%r12), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, 0x18(%rbx)
leaq 0xb810(%rip), %rax      # 0xb6055
movq %rax, (%rbx)
movabsq $0x100000004, %rax      # imm = 0x100000004
movq %rax, 0x60(%rbx)
movl $0x7, 0x70(%rbx)
movb $0x1, %al
jmp 0xaa86a
movl %ebp, 0x2258(%r15)
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_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x30, (%rdx)
jb 0xab6ba
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
sete %dl
je 0xab6b6
cmpl $0x32, (%rax)
je 0xab6ae
movq 0x10(%rax), %rax
testq %rax, %rax
sete %dl
je 0xab6b6
cmpl $0x32, (%rax)
jne 0xab69d
movq 0x8(%rax), %rcx
xorl %edx, %edx
jmp 0xab6b6
testb %dl, %dl
je 0xab6bc
xorl %ecx, %ecx
testq %rcx, %rcx
je 0xab76b
movl 0x2258(%r14), %ebp
movq %rcx, 0x18(%rbx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
cmpb $0x8, (%rcx)
jne 0xab764
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
cmpb $0xa, (%rcx)
jne 0xab764
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa66f0
testb %al, %al
je 0xab764
movq 0x10(%r15), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xac2d6
testq %rax, %rax
je 0xab764
movslq %ebp, %rcx
movq 0x8(%r15), %rdx
movq %rdx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
leaq 0xae73(%rip), %rax      # 0xb65a0
movq %rax, (%rbx)
movq 0x2260(%r14,%rcx,8), %rax
movq %rax, 0x20(%rbx)
movq 0x2260(%r14,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x28(%rbx)
movabsq $0x100000006, %rax      # imm = 0x100000006
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
movb $0x1, %al
jmp 0xab76d
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_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testb $0x20, 0x2(%rdx)
je 0xac25c
movl %r8d, %ebp
movq %rdx, %r12
decl %ebp
movslq %ebp, %rax
cmpq %rax, 0x18(%rdx)
jg 0xac25c
cmpq %rax, 0x28(%r12)
jl 0xac25c
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movq %rax, 0x8(%rsi)
movq %rcx, %r15
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0xac1f2
movq %r13, %rdi
movq %r15, %rsi
callq 0xa8bbb
testb %al, %al
jne 0xac1d9
movq 0x110(%r13), %rdx
cmpq %rdx, %r15
jne 0xac25c
leaq 0x9580(%rip), %rax      # 0xb5785
movq %rax, (%rbx)
cmpw $0x801, (%r14)          # imm = 0x801
jne 0xac225
movzwl 0x4(%r14), %eax
leal -0x17f(%rax), %ecx
cmpl $0x7, %ecx
jb 0xac225
cmpl $0x4, %eax
jae 0xac271
movq 0x8(%r12), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %rdx, %r12
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
callq *0x48(%rax)
movq %r12, %rdx
movq %rax, %r14
addq $0x10, %r14
movq (%r14), %rax
movq %rax, 0x10(%rbx)
movq $0x3, 0x60(%rbx)
cmpq %rdx, %r15
je 0xac26d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0xac25e
addq $0x20, %r14
jmp 0xac248
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: p_fx_any_ok
static bool p_fx_any_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer x)
                {
                    s7_function f;
                    if (has_fx(x))
                        f = c_callee(x);
                    else f = fx_choose(sc, x, sc->envir, let_symbol_is_safe);
                    if (f)
                    {
                        opc->v[0].fp = opt_p_fx_any;
                        opc->v[1].call = f;
                        opc->v[2].p = car(x);
                        return(oo_set_type_0(opc, 3));
                    }
                    return(return_false(sc, x, __func__, __LINE__));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
testb $0x4, 0x6(%rdx)
jne 0xac29c
movq 0x8(%rdi), %rdx
leaq 0xbef6(%rip), %rcx      # 0xb8188
movq %r14, %rsi
callq 0xb69b9
jmp 0xac2a0
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xac2c3
leaq 0xbf69(%rip), %rcx      # 0xb8215
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq $0x3, 0x60(%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_cell_quote
static bool opt_cell_quote(s7_scheme *sc, s7_pointer car_x)
                {
                    opt_info *opc;
                    if (!is_null(cddr(car_x)))
                        return(return_false(sc, car_x, __func__, __LINE__));
                    opc = alloc_opo(sc, car_x);
                    opc->v[1].p = cadr(car_x);
                    opc->v[0].fp = opt_p_c;
                    return(oo_set_type_0(opc, 2));
                }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x110(%rdi), %rcx
cmpq %rcx, %rax
jne 0xac3b3
movslq 0x2258(%rdi), %rdx
cmpq $0x100, %rdx            # imm = 0x100
jge 0xac3ba
leal 0x1(%rdx), %r8d
movl %r8d, 0x2258(%rdi)
movq 0x2260(%rdi,%rdx,8), %rdx
movq $0x0, 0x38(%rdx)
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rdx)
leaq -0xd7(%rip), %rsi       # 0xac2d1
movq %rsi, (%rdx)
movq $0x2, 0x60(%rdx)
cmpq %rcx, %rax
sete %al
retq
pushq %rax
addq $0x2190, %rdi           # imm = 0x2190
movl $0x1, %esi
callq 0x9530
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_cell_begin
static bool opt_cell_begin(s7_scheme *sc, s7_pointer car_x, int32_t len)
                {
                    opt_info *opc;
                    s7_pointer p;
                    opc = alloc_opo(sc, car_x);
                    for (p = cdr(car_x); is_pair(p); p = cdr(p))
                    {
                        opt_info *start;
                        start = sc->opts[sc->pc];
                        if (!cell_optimize(sc, p))
                            return(return_false(sc, car_x, __func__, __LINE__));
                        if (is_pair(cdr(p)))
                            oo_idp_nr_fixup(start);
                    }
                    opc->v[1].i = len - 1;
                    opc->v[0].fp = (len == 3) ? opt_begin_p_1 : opt_begin_p;
                    return(oo_set_type_0(opc, 2));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rdi, %r14
movslq 0x2258(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0xad39f
movq %rsi, %r15
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
movq 0x2260(%r14,%rax,8), %r13
movq $0x0, 0x38(%r13)
movq 0x10(%r15), %r15
movb (%r15), %bl
cmpb $0x1, %bl
jne 0xad35e
movslq 0x2258(%r14), %rax
movq 0x2260(%r14,%rax,8), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8bbb
testb %al, %al
je 0xad38a
movl %eax, %ebp
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0xad357
movq %r12, %rdi
callq 0xb080a
testb %bpl, %bpl
jne 0xad31a
jmp 0xad38a
movq (%rsp), %rcx
leal -0x1(%rcx), %eax
movq %rax, 0x8(%r13)
cmpl $0x3, %ecx
leaq 0x3525(%rip), %rax      # 0xb0898
leaq 0x355a(%rip), %rcx      # 0xb08d4
cmoveq %rax, %rcx
movq %rcx, (%r13)
movq $0x2, 0x60(%r13)
cmpb $0x1, %bl
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x2190, %r14           # imm = 0x2190
movq %r14, %rdi
movl $0x1, %esi
callq 0x9530
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_cell_when
static bool opt_cell_when(s7_scheme *sc, s7_pointer car_x, int32_t len)
                {
                    s7_pointer p;
                    opt_info *opc;
                    opc = alloc_opo(sc, car_x);
                    if (!bool_optimize(sc, cdr(car_x)))
                        return(return_false(sc, car_x, __func__, __LINE__));
                    for (p = cddr(car_x); is_pair(p); p = cdr(p))
                    {
                        opt_info *start;
                        start = sc->opts[sc->pc];
                        if (!cell_optimize(sc, p))
                            return(return_false(sc, car_x, __func__, __LINE__));
                        if (is_pair(cdr(p)))
                            oo_idp_nr_fixup(start);
                    }
                    opc->v[1].i = len - 2;
                    opc->v[3].i = sc->pc - 1;
                    opc->v[0].fp = ((car(car_x) == sc->when_symbol) ? opt_when_p : opt_unless_p);
                    return(oo_set_type_0(opc, 4));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x2258(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0xad4a4
movl %edx, %r12d
movq %rsi, %r14
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%rbx)
movq 0x2260(%rbx,%rax,8), %r15
movq $0x0, 0x38(%r15)
movq 0x10(%rsi), %rsi
movq %rbx, %rdi
callq 0xb0a63
testb %al, %al
je 0xad44e
movq %r12, (%rsp)
movq 0x10(%r14), %r12
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0xad45f
movslq 0x2258(%rbx), %rax
movq 0x2260(%rbx,%rax,8), %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa8bbb
testb %al, %al
je 0xad44e
movl %eax, %ebp
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0xad449
movq %r13, %rdi
callq 0xb080a
testb %bpl, %bpl
jne 0xad40b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rax
addl $-0x2, %eax
movq %rax, 0x8(%r15)
movslq 0x2258(%rbx), %rax
decq %rax
movq %rax, 0x18(%r15)
movq 0x8(%r14), %rax
cmpq 0x17f8(%rbx), %rax
leaq 0x3655(%rip), %rax      # 0xb0adf
leaq 0x36dc(%rip), %rcx      # 0xb0b6d
cmoveq %rax, %rcx
movq %rcx, (%r15)
movq $0x4, 0x60(%r15)
movb $0x1, %al
jmp 0xad450
addq $0x2190, %rbx           # imm = 0x2190
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9530
// File: /workspace/github_c_makefile_star2_O1/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 0xaee3a
movq 0x8(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xaedfc
leaq 0x9fb5a(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0xaee3a
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xaee15
callq 0xb389
movq 0x68(%rbx), %rax
movq 0x90(%rax), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rax)
movq -0x8(%rcx), %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_O1/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 0xaefb3
leaq 0x9f9a3(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0xaeff1
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xaefcc
callq 0xb389
movq 0x68(%rbx), %rax
movq 0x90(%rax), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rax)
movq -0x8(%rcx), %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_O1/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 0xaf216
movsd 0x8(%rax), %xmm0
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xaf1f0
movsd %xmm0, 0x8(%rsp)
callq 0xb389
movsd 0x8(%rsp), %xmm0
movq 0x68(%rbx), %rax
movq 0x90(%rax), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rax)
movq -0x8(%rcx), %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_O1/BernardTatin[P]s7sh/s7.c
// Function: set_p_d_f_combinable
static bool set_p_d_f_combinable(s7_scheme *sc, opt_info *opc)
                {
                    if ((sc->pc > 3) &&
                            (opc == sc->opts[sc->pc - 4]))
                    {
                        opt_info *o1;
                        o1 = sc->opts[sc->pc - 3];
                        if ((o1->v[0].fd == opt_d_mm_fff) &&
                                ((o1->v[3].d_dd_f == add_d_dd) || (o1->v[3].d_dd_f == subtract_d_dd)))
                        {
                            /* opc->v[2].d_dd_f = o1->v[3].d_dd_f; */
                            opc->v[0].fp = (o1->v[3].d_dd_f == add_d_dd) ? opt_set_p_d_f_mm_add : opt_set_p_d_f_mm_subtract;
                            return(true);
                        }
                    }
                    return(return_false(sc, NULL, __func__, __LINE__));
                }

// Assembly:
movl 0x2258(%rdi), %eax
cmpl $0x4, %eax
jl 0xaf292
leal -0x4(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xaf292
addl $-0x3, %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq 0x114a(%rip), %rcx      # 0xb0398
cmpq %rcx, (%rax)
jne 0xaf292
movq 0x18(%rax), %rax
leaq -0x22270(%rip), %rcx    # 0x8cfee
cmpq %rcx, %rax
setne %dl
leaq -0x22278(%rip), %rdi    # 0x8cff3
cmpq %rdi, %rax
setne %dil
testb %dil, %dl
jne 0xaf292
cmpq %rcx, %rax
leaq 0x11cc(%rip), %rax      # 0xb044d
leaq 0x12e4(%rip), %rcx      # 0xb056c
cmoveq %rax, %rcx
movq %rcx, (%rsi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaf2d3
movsd %xmm0, 0x8(%rsp)
callq 0xb389
movsd 0x8(%rsp), %xmm0
movq 0x68(%rbx), %rax
movq 0x90(%rax), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rax)
movq -0x8(%rcx), %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_O1/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 0xaf62a
cmpq %rsi, 0x11e0(%rdi)
je 0xaf62a
cmpq %rsi, 0x1180(%rdi)
je 0xaf62a
cmpq %rsi, 0x1038(%rdi)
je 0xaf62a
cmpq %rsi, 0x1120(%rdi)
je 0xaf62a
cmpq %rsi, 0x1178(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_set_p_p_f
static s7_pointer opt_set_p_p_f(opt_info *o)
                {
                    s7_pointer x;
                    oo_rc(o->sc, o, 5, 1);
                    o->sc->pc++;
                    x = o->v[4].fp(o->v[3].o1);
                    slot_set_value(o->v[1].p, x);
                    return(x);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
incl 0x2258(%rax)
movq 0x18(%rdi), %rdi
callq *0x20(%rbx)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
testq %rdx, %rdx
js 0xaf6a5
movq %rsi, %r12
cmpq %r15, 0x8(%rsi)
jle 0xaf6a5
cmpq $0x0, 0x6a0(%r14)
js 0xaf743
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0xaf720
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0xaf73a
movq 0x1668(%r14), %rax
movq 0x8(%rax), %rax
movq 0x9f2a9(%rip), %rcx     # 0x14e960
movq 0x1f00(%r14), %rdx
movq %r15, 0x8(%rdx)
movq 0x1ee8(%r14), %rdx
testq %r15, %r15
leaq 0xa3375(%rip), %rsi     # 0x152a48
leaq 0xa3366(%rip), %rdi     # 0x152a40
cmovsq %rsi, %rdi
movq 0x1f00(%r14), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%r14), %rsi
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
callq 0x3b366
jmp 0xaf79c
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xbd41
cmpq 0x120(%r14), %rax
je 0xaf74e
movq 0x10(%r12), %rax
movq %rbx, (%rax,%r15,8)
jmp 0xaf79c
movq 0x28(%r12), %rsi
cmpb $0x30, (%rsi)
jb 0xaf75e
movq 0x8(%rsi), %rax
jmp 0xaf772
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0xa05a7
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xa0491
leaq 0x6c2bf(%rip), %rsi     # 0x11ba48
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
callq 0xe25f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq