LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_subtract_2f
static s7_pointer g_subtract_2f(s7_scheme *sc, s7_pointer args) /* (- x f) */
    {
        s7_pointer x;
        s7_double n;

        x = car(args);
        n = real(cadr(args));
        if (is_float(x)) return(make_real(sc, real(x) - n));

        switch (type(x))
        {
            case T_INTEGER: return(make_real(sc, integer(x) - n));
            case T_RATIO:   return(make_real(sc, fraction(x) - n));
            case T_REAL:    return(make_real(sc, real(x) - n));
            case T_COMPLEX: return(s7_make_complex(sc, real_part(x) - n, imag_part(x)));
            default:
                            return(method_or_bust_with_type(sc, x, sc->subtract_symbol, args, a_number_string, 1));
        }
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x9245a
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
movsd 0x8(%rcx), %xmm2
leaq 0x42281(%rip), %rcx     # 0xd4628
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq 0x8(%rsi), %xmm0
jmp 0x923bd
movsd 0x8(%rsi), %xmm0
subsd %xmm2, %xmm0
jmp 0x9240e
movsd 0x8(%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
subsd %xmm2, %xmm0
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0xc152
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rax, 0x28(%rsp)
fildll 0x28(%rsp)
movq %rcx, 0x20(%rsp)
fildll 0x20(%rsp)
fdivrp %st, %st(1)
movsd %xmm2, 0x18(%rsp)
fsubl 0x18(%rsp)
fstpl 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92439
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x30, %rsp
popq %rbx
retq
movq 0x1588(%rbx), %rdx
movq 0x91f38(%rip), %r8      # 0x1243a0
pushq $0x1
popq %r9
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_mul_xf
static s7_pointer g_mul_xf(s7_scheme *sc, s7_pointer x, s7_double y)
    {
        switch (type(x))
        {
            case T_INTEGER: return(make_real(sc, integer(x) * y));
            case T_RATIO:   return(make_real(sc, numerator(x) * y / denominator(x)));
            case T_REAL:    return(make_real(sc, real(x) * y));
            case T_COMPLEX: return(s7_make_complex(sc, real_part(x) * y, imag_part(x) * y));
            default:
                            return(method_or_bust_with_type(sc, x, sc->multiply_symbol, list_2(sc, make_real(sc, y), x), a_number_string, 1));
        }
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x92853
leaq 0x41f2e(%rip), %rcx     # 0xd4648
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq 0x8(%r14), %xmm0
mulsd %xmm1, %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92758
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0x92845
mulsd 0x8(%r14), %xmm1
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x927a9
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm1
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm1, 0x8(%rax)
jmp 0x92845
movsd 0x8(%r14), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x10(%r14), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc152
cvtsi2sdq 0x8(%r14), %xmm2
mulsd %xmm1, %xmm2
cvtsi2sdq 0x10(%r14), %xmm0
divsd %xmm0, %xmm2
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x9282a
movq %rbx, %rdi
movsd %xmm2, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm2
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm2, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1358(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92885
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm1
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0xd, (%r12)
movsd %xmm1, 0x8(%r12)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x928c9
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r12, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0x91a90(%rip), %r8      # 0x1243a0
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_xi_1
static s7_pointer fx_num_eq_xi_1(s7_scheme *sc, s7_pointer args, s7_pointer val, s7_int y)
                {
#if S7_DEBUGGING
                    if (is_t_integer(val)) fprintf(stderr, "%s[%d]: %s is an integer\n", __func__, __LINE__, DISPLAY(val));
#endif
                    switch (type(val))
                    {
                        case T_RATIO:   return(sc->F);
                        case T_REAL:    return(make_boolean(sc, real(val) == y));
                        case T_COMPLEX: return(sc->F);
                        default: return(method_or_bust_with_type(sc, val, sc->num_eq_symbol, list_2(sc, val, cadr(args)), a_number_string, 1));
                    }
                    return(sc->T);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpl $0xe, %eax
je 0x92950
movq %rdx, %r14
cmpl $0xd, %eax
je 0x92959
cmpl $0xc, %eax
jne 0x9297f
movq 0x120(%rbx), %rax
jmp 0x92975
cvtsi2sd %rcx, %xmm0
cmpneqsd 0x8(%r14), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movq 0x118(%rbx,%rax,8), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xea0(%rbx), %r15
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x929b4
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0x919a5(%rip), %r8      # 0x1243a0
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: old_frame_with_slot
static s7_pointer old_frame_with_slot(s7_scheme *sc, s7_pointer env, s7_pointer val)
    {
        s7_pointer x, sym;
        uint64_t id;

        id = ++sc->let_number;
        let_id(env) = id;
        x = let_slots(env);
        slot_set_value(x, val);
        sym = slot_symbol(x);
        symbol_set_local(sym, id, x);
        return(env);
    }

// Assembly:
movq %rsi, %rax
movq 0x250(%rdi), %rcx
incq %rcx
movq %rcx, 0x250(%rdi)
movq %rcx, 0x18(%rsi)
movq 0x8(%rsi), %rsi
movq %rdx, 0x10(%rsi)
movq 0x8(%rsi), %rdx
movq %rsi, 0x18(%rdx)
movq %rcx, 0x20(%rdx)
incl 0x28(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: lint_let_ref_1
static s7_pointer lint_let_ref_1(s7_scheme *sc, s7_pointer lt, s7_pointer sym)
    {
        s7_pointer x, y;
        for (x = lt; is_let(x); x = outlet(x))
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == sym)
                    return(slot_value(y));

        if (has_methods(lt))
        {
            if (has_let_ref_fallback(lt))
                return(call_let_ref_fallback(sc, lt, sym));
        }
        else
        {
            y = global_slot(sym);
            if (is_slot(y))
                return(slot_value(y));
        }
        return(sc->undefined);
    }

// Assembly:
movq %rsi, %rax
cmpb $0x1c, (%rax)
jne 0x92a71
leaq 0x8(%rax), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x92a66
cmpq %rdx, 0x8(%rcx)
je 0x92a6c
addq $0x18, %rcx
jmp 0x92a52
movq 0x10(%rax), %rax
jmp 0x92a49
movq 0x10(%rcx), %rax
retq
movq (%rsi), %rax
btl $0x1e, %eax
jb 0x92a88
movq 0x10(%rdx), %rax
cmpb $0x20, (%rax)
jne 0x92a96
movq 0x10(%rax), %rax
retq
notl %eax
testl $0x44000000, %eax       # imm = 0x44000000
jne 0x92a96
jmp 0xaa3e
movq 0x128(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_types_match
static s7_pointer opt_types_match(s7_scheme *sc, s7_pointer check, s7_pointer sym)
                {
                    s7_pointer slot, checker;
                    checker = s7_symbol_value(sc, check);
                    slot = symbol_to_slot(sc, sym);
                    if (is_slot(slot))
                    {
                        s7_pointer obj;
                        obj = slot_value(slot);
                        if (s7_apply_function(sc, checker, set_plist_1(sc, obj)) == sc->T)
                            return(slot);
                    }
                    return(NULL);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x94b4
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb00b
cmpb $0x20, (%rax)
jne 0x92f6b
movq %rax, %r14
movq 0x10(%rax), %rax
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa34c
cmpq 0x118(%rbx), %rax
je 0x92f6e
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_i_add_any_f
static s7_int opt_i_add_any_f(opt_info *o)
                {
                    s7_int sum = 0;
                    int32_t i;
                    oo_rc(o->sc, o, 2, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        sum += o1->v[0].fi(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpq %r15, 0x8(%rbx)
jle 0x932e0
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
addq %rax, %r14
incq %r15
jmp 0x932b3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_i_multiply_any_f
static s7_int opt_i_multiply_any_f(opt_info *o)
                {
                    s7_int sum = 1;
                    int32_t i;
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        sum *= o1->v[0].fi(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
xorl %r15d, %r15d
cmpq %r15, 0x8(%r14)
jle 0x93325
movq 0x68(%r14), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
imulq %rax, %rbx
incq %r15
jmp 0x932f7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_d_add_any_f
static s7_double opt_d_add_any_f(opt_info *o)
                {
                    s7_double sum = 0.0;
                    int32_t i;
                    oo_rc(o->sc, o, 2, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        sum += o1->v[0].fd(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
cmpq %r14, 0x8(%rbx)
jle 0x94ab1
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
movsd %xmm0, (%rsp)
callq *(%rdi)
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
jmp 0x94a6f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_d_multiply_any_f
static s7_double opt_d_multiply_any_f(opt_info *o)
                {
                    s7_double sum = 1.0;
                    int32_t i;
                    oo_rc(o->sc, o, 2, 0);
                    for (i = 0; i < o->v[1].i; i++)
                    {
                        opt_info *o1;
                        o1 = o->sc->opts[++o->sc->pc];
                        sum *= o1->v[0].fd(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x3d568(%rip), %xmm0    # 0xd2030
xorl %r14d, %r14d
cmpq %r14, 0x8(%rbx)
jle 0x94b0d
movq 0x68(%rbx), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
movsd %xmm0, (%rsp)
callq *(%rdi)
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
jmp 0x94acb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_d_subtract_any_f
static s7_double opt_d_subtract_any_f(opt_info *o)
                {
                    opt_info *o1;
                    s7_double sum;
                    int32_t i;
                    s7_scheme *sc;
                    sc = o->sc;
                    oo_rc(o->sc, o, 2, 0);
                    o1 = sc->opts[++sc->pc];
                    sum = o1->v[0].fd(o1);
                    for (i = 1; i < o->v[1].i; i++)
                    {
                        o1 = sc->opts[++sc->pc];
                        sum -= o1->v[0].fd(o1);
                    }
                    return(sum);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
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)
pushq $0x1
popq %r15
cmpq %r15, 0x8(%rbx)
jle 0x94b87
movslq 0x2258(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
movsd %xmm0, 0x8(%rsp)
callq *(%rdi)
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r15
jmp 0x94b45
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: copy_list_with_arglist_error
static s7_pointer copy_list_with_arglist_error(s7_scheme *sc, s7_pointer lst)
                {
                    s7_pointer p, tp, np;
                    if (is_null(lst)) return(sc->nil);
                    if (!is_pair(lst))
                        s7_error(sc, sc->syntax_error_symbol, set_elist_2(sc, wrap_string(sc, "stray dot?: ~S", 14), lst));
                    sc->u = lst;
                    tp = cons(sc, car(lst), sc->nil);
                    sc->y = tp;
                    for (p = cdr(lst), np = tp; is_pair(p); p = cdr(p), np = cdr(np))
                        set_cdr(np, cons(sc, car(p), sc->nil));
                    sc->y = sc->nil;
                    sc->u = sc->nil;
                    if (!is_null(p))
                        s7_error(sc, sc->syntax_error_symbol, set_elist_2(sc, wrap_string(sc, "improper list of arguments: ~S", 30), lst));
                    return(tp);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x110(%rdi), %r12
cmpq %rsi, %r12
je 0x94d56
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
je 0x94c1e
movq 0x1918(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x4ebe5(%rip), %rcx     # 0xe37c7
movq %rcx, 0x10(%rax)
movq $0xe, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
callq 0x2cdc0
movq 0x110(%rbx), %r12
movq %r14, 0x4c8(%rbx)
movq %r14, (%rsp)
movq 0x8(%r14), %r13
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x94c4c
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r13, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r15, 0x4e8(%rbx)
movq %r15, %r13
movq (%rsp), %r12
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x94cd6
movq 0x8(%r12), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x94caf
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq %rax, %r13
jmp 0x94c78
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
cmpq %rax, %r12
je 0x94d59
movq 0x1918(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x4eabb(%rip), %rcx     # 0xe37d6
movq %rcx, 0x10(%rax)
movq $0x1e, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
callq 0x2cdc0
jmp 0x94d59
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_function_is_ok
static bool c_function_is_ok(s7_scheme *sc, s7_pointer x)
                {
                    /* macro version of this (below) is much slower! Since this is almost never false,
                     *   I tried __builtin_expect throughout eval below.  The result was not faster.
                     */
                    s7_pointer p;

                    p = car(x);               /* function name (symbol) */
                    if (is_global(p))
                        p = slot_value(global_slot(p));
                    else p = lookup_checked(sc, p);

                    /* this is nearly always global and p == opt1_cfunc(x)
                     * p can be null if we evaluate some code, optimizing it, then eval it again in a context
                     *   where the incoming p was undefined(!) -- explicit use of eval and so on.
                     *   I guess ideally eval would ignore optimization info -- copy :readable or something.
                     */
                    return((p == opt1_any(x)) ||
                            ((is_any_c_function(p)) &&
                             (c_function_class(p) == c_function_class(opt1_cfunc(x)))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %r14
testb $0x1, 0x2(%r14)
jne 0x94ef1
movq %rdi, %r15
movq %r14, %rsi
callq 0x7d158
testq %rax, %rax
jne 0x94ef9
movq %r15, %rdi
movq %r14, %rsi
callq 0x7d1b2
jmp 0x94ef9
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x94f1a
cmpb $0x2f, (%rax)
jb 0x94f1e
movq 0x8(%rax), %rax
movl 0xc(%rax), %eax
movq 0x8(%rcx), %rcx
cmpl 0xc(%rcx), %eax
sete %al
jmp 0x94f20
movb $0x1, %al
jmp 0x94f20
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_all_s
static s7_pointer fx_c_all_s(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer args, p, lst;
                    lst = safe_list_if_possible(sc, integer(opt3_arglen(arg)));
                    if (in_heap(lst))
                        gc_protect_direct(sc, lst);
                    for (args = cdr(arg), p = lst; is_pair(args); args = cdr(args), p = cdr(p))
                        set_car(p, lookup(sc, car(args)));
                    p = c_call(arg)(sc, lst);
                    if (in_heap(lst))
                        sc->stack_end -= 4;
                    else clear_list_in_use(lst);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x8b2f5
movq %rax, %r15
testb $0x40, 0x7(%rax)
jne 0x94f6b
movq 0x50(%rbx), %rax
movq $0x1, 0x18(%rax)
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r15, 0x10(%rax)
leaq 0x10(%r14), %r12
movq %r15, %r13
movq (%r12), %r12
cmpb $0x1, (%r12)
jne 0x94f98
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x7d158
movq %rax, 0x8(%r13)
addq $0x10, %r12
movq 0x10(%r13), %r13
jmp 0x94f72
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testb $0x40, 0x7(%r15)
jne 0x94fb0
addq $-0x20, 0x50(%rbx)
jmp 0x94fbc
andb $-0x5, 0x1(%r15)
andl $0x0, 0x2138(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_s_opaq
static s7_pointer fx_c_s_opaq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer arg2;
                    arg2 = cdaddr(arg);
                    set_car(sc->t1_1, fx_call(sc, arg2));
                    set_car(sc->t2_2, c_call(caddr(arg))(sc, sc->t1_1));
                    set_car(sc->t2_1, lookup_checked(sc, cadr(arg)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d158
testq %rax, %rax
jne 0x95192
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d1b2
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opaq_s
static s7_pointer fx_c_opaq_s(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer arg2;
                    arg2 = cdadr(arg);
                    set_car(sc->t1_1, fx_call(sc, arg2));
                    set_car(sc->t2_1, c_call(cadr(arg))(sc, sc->t1_1));
                    set_car(sc->t2_2, lookup_checked(sc, caddr(arg)));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d158
testq %rax, %rax
jne 0x95222
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7d1b2
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_s_opaaaq
static s7_pointer fx_c_s_opaaaq(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer arg;
                    arg = caddr(code);
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    gc_protect_direct(sc, fx_call(sc, cdr(arg)));
                    sc->stack_end[-4] = fx_call(sc, cddr(arg));
                    set_car(sc->t3_3, fx_call(sc, cdddr(arg)));
                    set_car(sc->t3_1, sc->stack_end[-2]);
                    set_car(sc->t3_2, sc->stack_end[-4]);
                    sc->stack_end -= 4;
                    set_car(sc->t2_2, c_call(arg)(sc, sc->t3_1));
                    set_car(sc->t2_1, lookup(sc, cadr(code)));
                    return(c_call(code)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, -0x20(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x20(%rax), %rax
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_ca
static s7_pointer fx_c_ca(s7_scheme *sc, s7_pointer arg)
                {
                    check_stack_size(sc);
                    set_car(sc->t2_2, fx_call(sc, cddr(arg)));
                    set_car(sc->t2_1, opt3_any(arg));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq 0x58(%rdi), %rax
jb 0x95407
movq %rbx, %rdi
callq 0x91caf
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x28(%r14), %rax
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_ac
static s7_pointer fx_c_ac(s7_scheme *sc, s7_pointer arg)
                {
                    check_stack_size(sc);
                    set_car(sc->t2_1, fx_call(sc, cdr(arg)));
                    set_car(sc->t2_2, opt3_any(arg));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq 0x58(%rdi), %rax
jb 0x95466
movq %rbx, %rdi
callq 0x91caf
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x28(%r14), %rax
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_sas
static s7_pointer fx_c_sas(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    p = cddr(arg);
                    set_car(sc->t3_2, fx_call(sc, p));
                    set_car(sc->t3_1, lookup(sc, cadr(arg)));
                    set_car(sc->t3_3, lookup(sc, cadr(p)));
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %r15
movq 0x8(%r15), %rsi
callq *0x20(%r15)
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_csa
static s7_pointer fx_c_csa(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    p = cddr(arg);
                    set_car(sc->t3_3, fx_call(sc, cdr(p)));
                    set_car(sc->t3_1, cadr(arg));
                    set_car(sc->t3_2, lookup(sc, car(p)));
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x590(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x580(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x7d158
movq 0x588(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x580(%r14), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_fx
static s7_pointer fx_c_fx(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer args, p, val;
                    val = safe_list_if_possible(sc, integer(opt3_arglen(arg)));
                    if (in_heap(val))
                        gc_protect_direct(sc, val);
                    for (args = cdr(arg), p = val; is_pair(args); args = cdr(args), p = cdr(p))
                        set_car(p, fx_call(sc, args));
                    p = c_call(arg)(sc, val);
                    if (in_heap(val))
                        sc->stack_end -= 4;
                    else clear_list_in_use(val);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x8b2f5
movq %rax, %r15
testb $0x40, 0x7(%rax)
jne 0x956d8
movq 0x50(%rbx), %rax
movq $0x1, 0x18(%rax)
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r15, 0x10(%rax)
leaq 0x10(%r14), %r12
movq %r15, %r13
movq (%r12), %r12
cmpb $0x1, (%r12)
jne 0x95705
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq %rax, 0x8(%r13)
addq $0x10, %r12
movq 0x10(%r13), %r13
jmp 0x956df
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testb $0x40, 0x7(%r15)
jne 0x9571d
addq $-0x20, 0x50(%rbx)
jmp 0x95729
andb $-0x5, 0x1(%r15)
andl $0x0, 0x2138(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_all_ca
static s7_pointer fx_c_all_ca(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer args, p, lst;
                    lst = safe_list_if_possible(sc, integer(opt3_arglen(code)));
                    if (in_heap(lst))
                        gc_protect_direct(sc, lst);
                    for (args = cdr(code), p = lst; is_pair(args); args = cdr(args), p = cddr(p))
                    {
                        set_car(p, opt2_any(args));
                        args = cdr(args);
                        set_car(cdr(p), fx_call(sc, args));
                    }
                    p = c_call(code)(sc, lst);
                    if (in_heap(lst))
                        sc->stack_end -= 4;
                    else clear_list_in_use(lst);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x8b2f5
movq %rax, %r15
testb $0x40, 0x7(%rax)
jne 0x95778
movq 0x50(%rbx), %rax
movq $0x1, 0x18(%rax)
movq 0x50(%rbx), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %r15, 0x10(%rax)
leaq 0x10(%r14), %r13
movq %r15, %r12
movq (%r13), %rax
cmpb $0x1, (%rax)
jne 0x957b8
movq 0x20(%rax), %rcx
movq %rcx, 0x8(%r12)
movq 0x10(%rax), %r13
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
movq 0x10(%r12), %rcx
movq %rax, 0x8(%rcx)
addq $0x10, %r13
movq 0x10(%r12), %rax
movq 0x10(%rax), %r12
jmp 0x9577f
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testb $0x40, 0x7(%r15)
jne 0x957d0
addq $-0x20, 0x50(%rbx)
jmp 0x957dc
andb $-0x5, 0x1(%r15)
andl $0x0, 0x2138(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_scs
static s7_pointer fx_c_scs(s7_scheme *sc, s7_pointer arg)
                {
                    set_car(sc->t3_1, lookup(sc, cadr(arg)));
                    set_car(sc->t3_3, lookup(sc, opt2_sym(cdr(arg)))); /* cadddr(arg) */
                    set_car(sc->t3_2, opt1_con(cdr(arg)));             /* caddr(arg) */
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x580(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0x7d158
movq 0x590(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x588(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x580(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_csc
static s7_pointer fx_c_csc(s7_scheme *sc, s7_pointer arg)
                {
                    set_car(sc->t3_2, lookup(sc, opt1_sym(cdr(arg)))); /* caddr(arg) */
                    set_car(sc->t3_1, opt3_any(cdr(arg)));
                    set_car(sc->t3_3, opt2_con(cdr(arg)));             /* cadddr(arg) */
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x18(%rax), %rsi
callq 0x7d158
movq 0x588(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x28(%rax), %rax
movq 0x580(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x20(%rax), %rax
movq 0x590(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x580(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_tus
static s7_pointer fx_c_tus(s7_scheme *sc, s7_pointer arg)
                {
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    check_next_let_slot(sc, __func__, arg, caddr(arg));
                    set_car(sc->t3_1, slot_value(let_slots(sc->envir)));
                    set_car(sc->t3_2, slot_value(next_slot(let_slots(sc->envir))));
                    set_car(sc->t3_3, lookup(sc, opt2_sym(cdr(arg)))); /* cadddr(arg) */
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x580(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq 0x588(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rsi
callq 0x7d158
movq 0x590(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x580(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_op_s_opsq_q
static s7_pointer fx_c_op_s_opsq_q(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer outer, args;
                    outer = cadr(arg);
                    args = caddr(outer);
                    set_car(sc->t1_1, lookup(sc, cadr(args)));
                    set_car(sc->t2_2, c_call(args)(sc, sc->t1_1));
                    set_car(sc->t2_1, lookup(sc, cadr(outer)));
                    set_car(sc->t1_1, c_call(outer)(sc, sc->t2_1));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r12
movq 0x10(%r12), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_op_opsq_s_q
static s7_pointer fx_c_op_opsq_s_q(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer outer, args;
                    outer = cadr(arg);
                    args = cadr(outer);
                    set_car(sc->t1_1, lookup(sc, cadr(args)));
                    set_car(sc->t2_1, c_call(args)(sc, sc->t1_1));
                    set_car(sc->t2_2, lookup(sc, caddr(outer)));
                    set_car(sc->t1_1, c_call(outer)(sc, sc->t2_1));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %r12
movq 0x10(%r12), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_opcsq
static s7_pointer fx_c_opcsq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = cadr(arg);
                    set_car(sc->t2_2, lookup(sc, caddr(largs)));
                    set_car(sc->t2_1, opt1_con(cdr(largs)));  /* cadr(largs) or cadadr */
                    set_car(sc->t1_1, c_call(largs)(sc, sc->t2_1));
                    return(c_call(arg)(sc, sc->t1_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x578(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x18(%rax), %rax
movq 0x570(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%r14), %rsi
movq %r14, %rdi
callq *0x20(%r15)
movq 0x568(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x568(%r14), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_c_opsq
static s7_pointer fx_c_c_opsq(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    largs = caddr(arg);
                    set_car(sc->t1_1, lookup(sc, cadr(largs)));
                    set_car(sc->t2_2, c_call(largs)(sc, sc->t1_1));
                    set_car(sc->t2_1, cadr(arg));
                    return(c_call(arg)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x568(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x568(%r14), %rsi
movq %r14, %rdi
callq *0x20(%r15)
movq 0x578(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x570(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x570(%r14), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_op_opssq_sq_s
static s7_pointer fx_c_op_opssq_sq_s(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer arg;
                    arg = opt3_pair(code); /* cadadr(code); */
                    set_car(sc->t2_1, lookup(sc, cadr(arg)));
                    set_car(sc->t2_2, lookup(sc, opt2_sym(cdr(arg))));
                    set_car(sc->t2_1, c_call(arg)(sc, sc->t2_1));
                    set_car(sc->t2_2, lookup(sc, caddr(cadr(code))));
                    set_car(sc->t2_1, c_call(cadr(code))(sc, sc->t2_1));
                    set_car(sc->t2_2, lookup(sc, caddr(code)));
                    return(c_call(code)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_op_opsq_q_c
static s7_pointer fx_c_op_opsq_q_c(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer arg;
                    arg = cadadr(code);
                    set_car(sc->t1_1, lookup(sc, cadr(arg)));
                    set_car(sc->t1_1, c_call(arg)(sc, sc->t1_1));
                    set_car(sc->t2_1, c_call(cadr(code))(sc, sc->t1_1));
                    set_car(sc->t2_2, caddr(code));
                    return(c_call(code)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_s_op_opsq_cq
static s7_pointer fx_c_s_op_opsq_cq(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer args, val, val1;
                    args = caddr(code);
                    val1 = cadr(args);
                    val = lookup(sc, cadr(val1));
                    set_car(sc->t1_1, val);
                    set_car(sc->t2_1, c_call(val1)(sc, sc->t1_1));
                    set_car(sc->t2_2, opt2_con(cdr(args)));                 /* caddr(args) E_C_PC in combine_ops */
                    set_car(sc->t2_2, c_call(args)(sc, sc->t2_1));
                    set_car(sc->t2_1, lookup(sc, cadr(code)));
                    return(c_call(code)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %r12
movq 0x10(%r12), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x568(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x568(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x20(%rax), %rax
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_c_s_op_opssq_opssqq
static s7_pointer fx_c_s_op_opssq_opssqq(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer args, op1, op2;
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    args = caddr(code);
                    op1 = cadr(args);
                    op2 = caddr(args);
                    set_car(sc->t2_1, lookup(sc, cadr(op1)));
                    set_car(sc->t2_2, lookup(sc, opt2_sym(cdr(op1))));
                    gc_protect_direct(sc, c_call(op1)(sc, sc->t2_1));
                    set_car(sc->t2_1, lookup(sc, cadr(op2)));
                    set_car(sc->t2_2, lookup(sc, opt2_sym(cdr(op2))));
                    set_car(sc->t2_2, c_call(op2)(sc, sc->t2_1));
                    set_car(sc->t2_1, sc->stack_end[-2]);
                    set_car(sc->t2_2, c_call(args)(sc, sc->t2_1));
                    set_car(sc->t2_1, lookup(sc, cadr(code)));
                    sc->stack_end -= 4;

                    return(c_call(code)(sc, sc->t2_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %r13
movq 0x10(%rax), %rax
movq 0x8(%rax), %r12
movq 0x10(%r13), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r13), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r13)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r12), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r12), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x570(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
movq 0x20(%r14), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax