LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_add_x1
static s7_pointer g_add_x1(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer x;
        x = car(args);
        if (is_t_integer(x))
            return(make_integer(sc, integer(x) + 1));
        return(g_add_x1_1(sc, x, args));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0xb, (%rsi)
jne 0xe15c8
movq 0x8(%rsi), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xe15d7
leaq 0x6d38f(%rip), %rcx     # 0x14e950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xe1610
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc1b57
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe15ef
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_num_eq_2
static s7_pointer g_num_eq_2(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer x, y;
        x = car(args);
        y = cadr(args);
        if ((is_t_integer(x)) && (is_t_integer(y))) /* this is by far the most common case (ratios aren't used much, and = with floats is frowned upon) */
            return(make_boolean(sc, integer(x) == integer(y)));
        return(num_eq_p_pp(sc, x, y));
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
cmpb $0xb, (%rsi)
jne 0x8fcc9
cmpb $0xb, (%rdx)
jne 0x8fcc9
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_num_eq_xi
static s7_pointer g_num_eq_xi(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer x, y;
        x = car(args);
        y = cadr(args);
        if (is_t_integer(x))
            return(make_boolean(sc, integer(x) == integer(y)));
        if (is_t_real(x))
            return(make_boolean(sc, real(x) == integer(y)));
        if (!is_number(x))
            return(eq_out_x(sc, x, y));
        return(sc->F);
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movzbl (%rsi), %eax
cmpl $0xd, %eax
je 0xe1681
cmpl $0xb, %eax
jne 0xe169e
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
cvtsi2sdq 0x8(%rdx), %xmm0
cmpneqsd 0x8(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movq 0x118(%rdi,%rax,8), %rax
retq
leaq 0x712cb(%rip), %rcx     # 0x152970
cmpb $0x0, (%rax,%rcx)
je 0xe16d4
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: do_tree_has_definers
static inline bool do_tree_has_definers(s7_scheme *sc, s7_pointer tree)
                {
                    /* we can't be very fancy here because quote gloms up everything: (cond '(define x 0) ...) etc, and the tree here can
                     *   be arbitrarily messed up, and we need to be reasonably fast.  So we accept some false positives: (case ((define)...)...) or '(define...)
                     * but what about ((f...)...) where (f...) returns a macro that defines something?
                     */
                    s7_pointer p;
                    for (p = tree; is_pair(p); p = cdr(p))
                    {
                        s7_pointer pp;
                        pp = car(p);
                        if (is_symbol(pp))
                        {
                            if ((is_definer(pp)) &&
                                    ((pp != sc->varlet_symbol) ||
                                     ((is_pair(cdr(p))) &&         /* if varlet, is target let local? */
                                      (is_symbol(cadr(p))) &&
                                      (!symbol_is_in_list(sc, cadr(p))))))
                            {
#if DO_PRINT
                                fprintf(stderr, "definer: %s\n", DISPLAY(pp));
#endif
                                return(true);
                            }
                        }
                        else
                        {
                            if ((is_pair(pp)) &&
                                    (do_tree_has_definers(sc, pp)))
                                return(true);
                        }
                    }
                    return(false);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x1, (%rsi)
sete %bl
jne 0xe1d2b
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%r14), %rsi
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0xe1d12
cmpl $0xa, %eax
jne 0xe1d1e
testb $0x4, 0x6(%rsi)
je 0xe1d1e
cmpq 0x1640(%r15), %rsi
jne 0xe1d2b
movq 0x10(%r14), %rax
cmpb $0x1, (%rax)
jne 0xe1d1e
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0xe1d1e
movl 0x2c(%rax), %ecx
cmpl 0xa88(%r15), %ecx
jne 0xe1d2b
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
cmpl 0xa8c(%r15), %eax
je 0xe1d1e
jmp 0xe1d2b
movq %r15, %rdi
callq 0xe1cab
testb %al, %al
jne 0xe1d2b
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
sete %bl
je 0xe1cbe
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_tree_outest
static void fx_tree_outest(s7_scheme *sc, s7_pointer tree, s7_pointer v1, s7_pointer v2, s7_pointer v3, s7_pointer v4)
                {
                    if ((!is_pair(tree)) ||
                            ((is_symbol(car(tree))) &&
                             (is_definer_or_binder(car(tree)))))
                        return;
                    if ((!has_fx(tree)) ||
                            (!fx_tree_out2(sc, tree, v1, v2, v3, v4)))
                        fx_tree_outest(sc, car(tree), v1, v2, v3, v4);
                    fx_tree_outest(sc, cdr(tree), v1, v2, v3, v4);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x1, (%r12)
jne 0xe2018
movq 0x8(%r12), %rbp
movb (%rbp), %al
cmpb $0xa, %al
jne 0xe1f77
testb $0xc, 0x6(%rbp)
jne 0xe2018
cmpb $0x1, %al
jne 0xe1f9f
movzwl 0x6(%r12), %eax
andl $0x4, %eax
je 0xe1f9f
movq 0x10(%rbp), %r13
cmpb $0x1, (%r13)
jne 0xe1f9f
leaq -0x896f(%rip), %rax     # 0xd9629
cmpq %rax, 0x20(%r12)
je 0xe1fb9
movq 0x8(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xe1f3f
movq 0x10(%r12), %r12
jmp 0xe1f56
movq 0x8(%r13), %rax
testq %rax, %rax
je 0xe1f9f
cmpq %rbx, %rax
je 0xe1f9f
cmpq %r15, %rax
je 0xe1f9f
cmpq %r14, %rax
je 0xe1f9f
movq 0x8(%rbp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
callq 0xb60a8
testq %rax, %rax
je 0xe1f9f
orb $0x8, 0x3(%rbp)
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
callq 0xb60a8
movq %rax, 0x20(%r13)
leaq 0xcab3(%rip), %rax      # 0xeeabe
movq %rax, 0x20(%r12)
orb $0x4, 0x6(%r12)
jmp 0xe1fb2
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: simple_stepper
static s7_pointer simple_stepper(s7_scheme *sc, s7_pointer v)
                {
                    if ((safe_list_length(v) == 3) &&
                            (is_fxable(sc, cadr(v))))
                    {
                        s7_pointer step_expr;
                        step_expr = caddr(v);
                        if ((is_optimized(step_expr)) &&
                                (((optimize_op(step_expr) == HOP_SAFE_C_SC) && (car(v) == cadr(step_expr))) ||
                                 ((is_h_safe_c_d(step_expr)) && /* replace with is_fxable? */
                                  (is_pair(cdr(step_expr))) &&         /* ((v 0 (+))) */
                                  (car(v) == cadr(step_expr)) &&
                                  ((opt1_cfunc(step_expr) == sc->add_x1) || (opt1_cfunc(step_expr) == sc->subtract_s1))) ||
                                 ((optimize_op(step_expr) == HOP_SAFE_C_CS) && (car(v) == caddr(step_expr)))))
                            return(step_expr);
                    }
                    return(NULL);
                }

// Assembly:
cmpb $0x1, (%rsi)
jne 0xe20d4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x3, %eax
movq %rsi, %rcx
movq 0x10(%rcx), %rcx
decq %rax
cmpb $0x1, (%rcx)
je 0xe2043
testq %rax, %rax
jne 0xe20cc
movq 0x10(%rbx), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xd5a05
testb %al, %al
je 0xe20cc
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
cmpw $0x801, (%rax)          # imm = 0x801
jne 0xe20cc
movzwl 0x4(%rax), %ecx
cmpl $0x3, %ecx
je 0xe20a2
cmpl $0xb, %ecx
je 0xe20ba
cmpl $0x9, %ecx
jne 0xe20cc
movq 0x8(%rbx), %rdx
movq 0x10(%rax), %rsi
cmpq 0x8(%rsi), %rdx
je 0xe20ce
cmpl $0xb, %ecx
je 0xe20ba
cmpl $0x3, %ecx
jne 0xe20cc
movq 0x10(%rax), %rdx
cmpb $0x1, (%rdx)
jne 0xe20b5
movq 0x8(%rbx), %rsi
cmpq 0x8(%rdx), %rsi
je 0xe20d7
cmpl $0xb, %ecx
jne 0xe20cc
movq 0x8(%rbx), %rcx
movq 0x10(%rax), %rdx
movq 0x10(%rdx), %rdx
cmpq 0x8(%rdx), %rcx
je 0xe20ce
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
movq 0x18(%rax), %rdx
cmpq 0x1a60(%r14), %rdx
je 0xe20ce
cmpq 0x1a80(%r14), %rdx
jne 0xe20b5
jmp 0xe20ce
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: is_simple_end
static bool is_simple_end(s7_scheme *sc, s7_pointer end)
                {
                    return((is_optimized(end)) &&
                            (is_safe_c_op(optimize_op(end))) &&
                            (is_pair(cddr(end))) &&      /* end: (zero? n) */
                            (cadr(end) != caddr(end)) &&
#if (!WITH_GMP)
                            ((opt1_cfunc(end) == sc->num_eq_xi) ||
                             (optimize_op(end) == HOP_SAFE_C_SS) || (optimize_op(end) == HOP_SAFE_C_SC)));
#else
                    ((optimize_op(end) == HOP_SAFE_C_SS) || (optimize_op(end) == HOP_SAFE_C_SC)));
#endif
                }

// Assembly:
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0xe21d1
movl 0x4(%rsi), %eax
leal -0x2(%rax), %ecx
movzwl %cx, %ecx
cmpl $0x9b, %ecx
ja 0xe21d1
movq 0x10(%rsi), %rcx
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0xe21d1
movq 0x8(%rcx), %rcx
cmpq 0x8(%rdx), %rcx
je 0xe21d1
movq 0x18(%rsi), %rcx
cmpq 0x1c60(%rdi), %rcx
sete %cl
cmpw $0x7, %ax
sete %dl
orb %cl, %dl
cmpw $0x9, %ax
sete %al
orb %dl, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_let
static s7_pointer make_permanent_let(s7_scheme *sc, s7_pointer vars)
    {
        s7_pointer frame, var, slot;
        frame = alloc_pointer(sc);

#if S7_DEBUGGING
        permanent_slots++;
#endif
        set_type(frame, T_LET | T_SAFE_PROCEDURE | T_UNHEAP);
        let_id(frame) = ++sc->let_number;
        set_outlet(frame, sc->envir);
        slot = make_permanent_slot(sc, caar(vars), sc->F);
        add_permanent_let_or_slot(sc, slot);
        symbol_set_local(caar(vars), sc->let_number, slot);
        let_set_slots(frame, slot);
        for (var = cdr(vars); is_pair(var); var = cdr(var))
        {
            s7_pointer last_slot;
            last_slot = slot;
            slot = make_permanent_slot(sc, caar(var), sc->F);
            add_permanent_let_or_slot(sc, slot);
            symbol_set_local(caar(var), sc->let_number, slot);
            slot_set_next(last_slot, slot);
        }
        slot_set_next(slot, slot_end(sc));
        add_permanent_let_or_slot(sc, frame); /* need to mark outlet and maybe slot values */
        return(frame);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movabsq $0x4000000000000020, %r14 # imm = 0x4000000000000020
callq 0xfa3b
movq %rax, %r13
leaq 0x1ffffc(%r14), %rax
movq %rax, (%r13)
movq 0x250(%rbx), %rax
incq %rax
movq %rax, 0x250(%rbx)
movq %rax, 0x18(%r13)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r13)
movq 0x8(%r12), %rax
movq 0x8(%rax), %rbp
movq 0x120(%rbx), %r14
movq %rbx, %rdi
callq 0xfa3b
movq %rax, %r15
movabsq $0x4000000000000020, %rax # imm = 0x4000000000000020
movq %rax, (%r15)
movq %rbp, 0x8(%r15)
movq %r14, 0x10(%r15)
movl $0x10, %edi
callq 0x9480
movq %r15, (%rax)
movq 0xc8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0xc8(%rbx)
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq %r15, 0x18(%rax)
movq 0x250(%rbx), %rax
movq 0x8(%r12), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
incl 0x28(%rax)
movq %r13, (%rsp)
movq %r15, 0x8(%r13)
movq 0x10(%r12), %rbp
cmpb $0x1, (%rbp)
jne 0xe2344
movq 0x8(%rbp), %rax
movq 0x8(%rax), %r14
movq 0x120(%rbx), %r13
movq %rbx, %rdi
callq 0xfa3b
movq %rax, %r12
movabsq $0x4000000000000020, %rax # imm = 0x4000000000000020
movq %rax, (%r12)
movq %r14, 0x8(%r12)
movq %r13, 0x10(%r12)
movl $0x10, %edi
callq 0x9480
movq %r12, (%rax)
movq 0xc8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0xc8(%rbx)
movq 0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %r12, 0x18(%rax)
movq 0x250(%rbx), %rax
movq 0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%rbp), %rax
movq 0x8(%rax), %rax
incl 0x28(%rax)
movq %r12, 0x18(%r15)
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
movq %r12, %r15
je 0xe22b2
jmp 0xe2347
movq %r15, %r12
movq $0x0, 0x18(%r12)
movl $0x10, %edi
callq 0x9480
movq (%rsp), %rdx
movq %rdx, (%rax)
movq 0xc8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0xc8(%rbx)
movq %rdx, %rax
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: collect_variables
static inline s7_pointer collect_variables(s7_scheme *sc, s7_pointer lst, s7_pointer e)
    {
        /* collect local variable names from let/do (pre-error-check) */
        s7_pointer p;
        sc->w = e;
        for (p = lst; is_pair(p); p = cdr(p))
            sc->w = cons(sc, add_symbol_to_list(sc, caar(p)), sc->w);
        return(sc->w);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdx, 0x4d8(%rdi)
cmpb $0x1, (%rsi)
jne 0xe2417
movq %rsi, %r14
movq 0x8(%r14), %rax
movq 0x8(%rax), %r15
movl 0xa88(%rbx), %eax
movl %eax, 0x2c(%r15)
movl 0xa8c(%rbx), %eax
movq 0x8(%r15), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x4d8(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe23e1
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x4d8(%rbx)
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xe239f
movq 0x4d8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_integer
static s7_pointer make_permanent_integer(s7_int i)
    {
        if (is_small(i)) return(small_int(i));

        if (i == MAX_ARITY) return(max_arity);
        if (i == CLOSURE_ARITY_NOT_SET) return(arity_not_set);
        if (i == -1) return(minus_one);
        if (i == -2) return(minus_two);
        /* a few -3 */

        return(make_permanent_integer_unchecked(i));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x7ff, %rdi            # imm = 0x7FF
ja 0xe8efd
leaq 0x65a59(%rip), %rax     # 0x14e950
movq (%rax,%rbx,8), %rax
popq %rbx
retq
cmpq $0x1fffffff, %rbx       # imm = 0x1FFFFFFF
jg 0xe8f1b
cmpq $-0x2, %rbx
je 0xe8f58
cmpq $-0x1, %rbx
jne 0xe8f36
movq 0x744df(%rip), %rax     # 0x15d3f8
jmp 0xe8efb
cmpq $0x40000000, %rbx       # imm = 0x40000000
je 0xe8f61
cmpq $0x20000000, %rbx       # imm = 0x20000000
jne 0xe8f36
movq 0x6b474(%rip), %rax     # 0x1543a8
jmp 0xe8efb
movl $0x1, %edi
movl $0x30, %esi
callq 0x9360
movabsq $0x400000000100000b, %rcx # imm = 0x400000000100000B
orq %rcx, (%rax)
movq %rbx, 0x8(%rax)
jmp 0xe8efb
movq 0x744a9(%rip), %rax     # 0x15d408
jmp 0xe8efb
movq 0x74498(%rip), %rax     # 0x15d400
jmp 0xe8efb
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_count
static int32_t fx_count(s7_scheme *sc, s7_pointer x)
                {
                    int32_t count = 0;
                    s7_pointer p;
                    for (p = cdr(x); is_pair(p); p = cdr(p))
                        if (is_fxable(sc, car(p)))
                            count++;
                    return(count);
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rsi), %r14
xorl %ebp, %ebp
cmpb $0x1, (%r14)
jne 0xe8f9a
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xd5a05
movzbl %al, %eax
addl %eax, %ebp
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xe8f7f
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: vars_opt_ok
static bool vars_opt_ok(s7_scheme *sc, s7_pointer vars, int32_t hop, s7_pointer e)
                {
                    s7_pointer p;
                    for (p = vars; is_pair(p); p = cdr(p))
                    {
                        s7_pointer init;
                        init = cadar(p);
                        if ((is_pair(init)) &&
                                (!is_checked(init)) &&
                                (optimize_expression(sc, init, hop, e, false) == OPT_OOPS))
                            return(false);
                    }
                    return(true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x1, (%rsi)
setne %r14b
jne 0xe8ff7
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xe8fe9
testb $0x40, 0x2(%rsi)
jne 0xe8fe9
movq %r12, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xe242a
cmpl $0x2, %eax
je 0xe8ff7
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
setne %r14b
je 0xe8fbd
andb $0x1, %r14b
movl %r14d, %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: collect_parameters
static s7_pointer collect_parameters(s7_scheme *sc, s7_pointer lst, s7_pointer e)
    {
        /* collect local variable names from lambda arglists (pre-error-check) */
        s7_pointer p;
        if (is_symbol(lst))
            return(cons(sc, add_symbol_to_list(sc, lst), e));
        sc->w = e;
        for (p = lst; is_pair(p); p = cdr(p))
        {
            s7_pointer car_p;
            car_p = car(p);
            if (is_pair(car_p))
                car_p = car(car_p);
            if (is_normal_symbol(car_p))
                sc->w = cons(sc, add_symbol_to_list(sc, car_p), sc->w);
        }
        if (is_symbol(p)) /* rest arg */
            sc->w = cons(sc, add_symbol_to_list(sc, p), sc->w);
        return(sc->w);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0xa, (%rsi)
jne 0xe907a
movl 0xa88(%rbx), %eax
movl %eax, 0x2c(%r14)
movl 0xa8c(%rbx), %eax
movq 0x8(%r14), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe9050
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
jmp 0xe918a
movq %r15, 0x4d8(%rbx)
movzbl (%r14), %eax
cmpl $0x1, %eax
jne 0xe9118
movq 0x8(%r14), %r15
cmpb $0x1, (%r15)
jne 0xe909c
movq 0x8(%r15), %r15
cmpb $0xa, (%r15)
jne 0xe910f
testb $-0x80, 0x6(%r15)
jne 0xe910f
movl 0xa88(%rbx), %eax
movl %eax, 0x2c(%r15)
movl 0xa8c(%rbx), %eax
movq 0x8(%r15), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x4d8(%rbx), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe90e3
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x4d8(%rbx)
movq 0x10(%r14), %r14
jmp 0xe9081
cmpl $0xa, %eax
jne 0xe9183
movl 0xa88(%rbx), %eax
movl %eax, 0x2c(%r14)
movl 0xa8c(%rbx), %eax
movq 0x8(%r14), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x4d8(%rbx), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe9157
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x4d8(%rbx)
movq 0x4d8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: optimize_func_dotted_args
static opt_t optimize_func_dotted_args(s7_scheme *sc, s7_pointer expr, s7_pointer func, int32_t hop, int32_t args, s7_pointer e)
                {
                    if (fx_count(sc, expr) == args) /* fx_count starts at cdr */
                    {
                        annotate_args(sc, cdr(expr), e);
                        set_opt3_arglen(expr, small_int(args));
                        set_unsafe_optimize_op(expr, hop + OP_CLOSURE_ANY_FX);
                        set_opt1_lambda(expr, func);
                        return(OPT_F);
                    }
                    return(OPT_F);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %r8d, %r15d
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
callq 0xe8f6a
cmpl %r15d, %eax
jne 0xe9b16
movq 0x10(%r14), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0xd9cf3
movslq %r15d, %rax
leaq 0x64e67(%rip), %rcx     # 0x14e950
movq (%rcx,%rax,8), %rax
movq 0x10(%r14), %rcx
movq %rax, 0x28(%rcx)
movq 0x10(%r14), %rax
andq $-0x40001, (%rax)       # imm = 0xFFFBFFFF
orq $0x800800, (%r14)       # imm = 0x800800
addl $0x10c, %ebp            # imm = 0x10C
movw %bp, 0x4(%r14)
movq %rbx, 0x18(%r14)
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: safe_c_aa_to_ca
static bool safe_c_aa_to_ca(s7_scheme *sc, s7_pointer arg, int hop)
                {
                    if (c_callee(cddr(arg)) == fx_c) {set_opt3_any(arg, caddr(arg)); set_safe_optimize_op(arg, hop + OP_SAFE_C_AC); return(true);}
                    if (c_callee(cdr(arg)) == fx_c)  {set_opt3_any(arg, cadr(arg));  set_safe_optimize_op(arg, hop + OP_SAFE_C_CA); return(true);}
                    if (c_callee(cddr(arg)) == fx_q) {set_opt3_any(arg, cadr(caddr(arg))); set_safe_optimize_op(arg, hop + OP_SAFE_C_AC); return(true);}
                    if (c_callee(cdr(arg)) == fx_q)  {set_opt3_any(arg, cadadr(arg));      set_safe_optimize_op(arg, hop + OP_SAFE_C_CA); return(true);}
                    return(false);
                }

// Assembly:
movq 0x10(%rdi), %rdx
movq 0x10(%rdx), %rax
movq 0x20(%rax), %rcx
addq $0x8, %rax
leaq -0x3193c(%rip), %r9     # 0xb8226
cmpq %r9, %rcx
je 0xe9b88
movq 0x20(%rdx), %r8
addq $0x8, %rdx
cmpq %r9, %r8
je 0xe9b8e
leaq -0x289f6(%rip), %r9     # 0xc1185
cmpq %r9, %rcx
je 0xe9b97
cmpq %r9, %r8
je 0xe9b9d
xorl %eax, %eax
retq
movw $0x72, %cx
jmp 0xe9baf
movw $0x70, %cx
movq %rdx, %rax
jmp 0xe9baf
movw $0x72, %cx
jmp 0xe9ba4
movw $0x70, %cx
movq %rdx, %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movq (%rax), %rax
movq %rax, 0x28(%rdi)
andb $-0x5, 0x2(%rdi)
orb $0x8, 0x1(%rdi)
movzwl %cx, %eax
addl %esi, %eax
movw %ax, 0x4(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: set_safe_closure_fp
static opt_t set_safe_closure_fp(s7_scheme *sc, s7_pointer func, s7_pointer expr, s7_pointer e, int32_t num_args, opcode_t op)
                {
                    s7_pointer p;
                    for (p = cdr(expr); is_pair(p); p = cdr(p))
                        set_c_call_checked(p, fx_choose(sc, p, e, (is_list(e)) ? pair_symbol_is_safe : let_symbol_is_safe));
                    set_opt3_arglen(expr, make_permanent_integer(num_args));
                    set_unsafe_optimize_op(expr, op);
                    set_opt1_lambda(expr, func);
                    return(OPT_F);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, 0x4(%rsp)
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq 0x10(%rdx), %rbx
cmpb $0x1, (%rbx)
jne 0xe9e9b
movq %rcx, %r12
movq %rdi, %r13
leaq -0x143d6(%rip), %r15    # 0xd5a7e
leaq -0x31cd3(%rip), %rbp    # 0xb8188
movb (%r12), %al
decb %al
cmpb $0x2, %al
movq %rbp, %rcx
cmovbq %r15, %rcx
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xb69b9
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movq %rax, 0x20(%rbx)
movzwl 0x6(%rbx), %eax
andl $-0x5, %eax
leal (%rax,%rcx,4), %eax
movw %ax, 0x6(%rbx)
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0xe9e5b
movslq 0x4(%rsp), %rdi
callq 0xe8ee3
movq 0x10(%r14), %rcx
movq %rax, 0x28(%rcx)
movq 0x10(%r14), %rax
andq $-0x40001, (%rax)       # imm = 0xFFFBFFFF
orq $0x800800, (%r14)       # imm = 0x800800
movq 0x10(%rsp), %rax
movw %ax, 0x4(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%r14)
addq $0x18, %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: unsafe_is_safe
static bool unsafe_is_safe(s7_scheme *sc, s7_pointer f, s7_pointer e)
                {
                    if (!is_symbol(f)) return(false);
                    f = find_uncomplicated_symbol(sc, f, e); /* how to catch local c-funcs here? */
                    if (is_slot(f))
                    {
                        f = slot_value(f);
                        return((is_c_function(f)) &&
                                (is_safe_procedure(f)));
                    }
                    return(false);
                }

// Assembly:
cmpb $0xa, (%rsi)
jne 0xe9f04
pushq %rax
callq 0xe3fba
cmpb $0x20, (%rax)
jne 0xe9f07
movq 0x10(%rax), %rax
cmpb $0x30, (%rax)
jb 0xe9f07
movb 0x2(%rax), %al
andb $0x20, %al
shrb $0x5, %al
jmp 0xe9f09
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: body_is_safe
static body_t body_is_safe(s7_scheme *sc, s7_pointer func, s7_pointer body, bool at_end)
                {
                    bool follow = false;
                    s7_pointer p, sp;
                    body_t result = VERY_SAFE_BODY;
                    /* fprintf(stderr, "%s: %s %s %d\n", __func__, DISPLAY(func), DISPLAY(body), at_end); */
                    for (p = body, sp = body; is_pair(p); p = cdr(p))
                    {
                        if (is_pair(car(p)))
                        {
                            result = min_body(result, form_is_safe(sc, func, car(p), (at_end) && (is_null(cdr(p)))));
                            if (result == UNSAFE_BODY) return_unsafe_body(sc);
                        }
                        if (p != body)
                        {
                            if (follow) {sp = cdr(sp); if (p == sp) return_unsafe_body(sc);}
                            follow = (!follow);
                        }
                    }
                    if (!is_null(p))
                        return_unsafe_body(sc);
                    return(result);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, (%rsp)
movl $0x3, %r13d
cmpb $0x1, (%rdx)
jne 0xea4c0
xorl %r15d, %r15d
movq %rbx, %rbp
movq %rbx, %r14
xorl %r12d, %r12d
movq 0x8(%r14), %rdx
cmpb $0x1, (%rdx)
jne 0xea49c
movl $0x0, %eax
cmpb $0x0, 0xc(%rsp)
je 0xea47f
movq 0x10(%r14), %rax
movq (%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
movzbl %al, %ecx
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xed697
cmpl %eax, %r13d
cmovael %eax, %r13d
testl %r13d, %r13d
je 0xea4d5
cmpq %rbx, %r14
je 0xea4b4
testb $0x1, %r15b
je 0xea4b0
movq 0x10(%rbp), %rbp
cmpq %rbp, %r14
je 0xea4e7
xorb $0x1, %r15b
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xea458
jmp 0xea4c3
movq %rbx, %r14
xorl %r12d, %r12d
movq (%rsp), %rax
cmpq 0x110(%rax), %r14
cmovel %r13d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0xea4d5
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: set_safe_c_fp
static opt_t set_safe_c_fp(s7_scheme *sc, s7_pointer func, s7_pointer expr, s7_pointer e, int32_t num_args, opcode_t op)
                {
                    s7_pointer p;
                    for (p = cdr(expr); is_pair(p); p = cdr(p))
                        set_c_call_checked(p, fx_choose(sc, p, e, (is_list(e)) ? pair_symbol_is_safe : let_symbol_is_safe));
                    set_opt3_arglen(expr, make_permanent_integer(num_args));
                    set_unsafe_optimize_op(expr, op);
                    choose_c_function(sc, expr, func, num_args);
                    return(OPT_F);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x10(%rdx), %r12
cmpb $0x1, (%r12)
jne 0xee561
movq %rcx, %r13
leaq -0x18a94(%rip), %rbp    # 0xd5a7e
leaq -0x36391(%rip), %r14    # 0xb8188
movb (%r13), %al
decb %al
cmpb $0x2, %al
movq %r14, %rcx
cmovbq %rbp, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xb69b9
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movq %rax, 0x20(%r12)
movzwl 0x6(%r12), %eax
andl $-0x5, %eax
leal (%rax,%rcx,4), %eax
movw %ax, 0x6(%r12)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xee519
movslq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0xe8ee3
movq 0x10(%rbx), %rcx
movq %rax, 0x28(%rcx)
movq 0x10(%rbx), %rax
andq $-0x40001, (%rax)       # imm = 0xFFFBFFFF
orq $0x800800, (%rbx)       # imm = 0x800800
movq 0x8(%rsp), %rax
movw %ax, 0x4(%rbx)
movq 0x10(%rsp), %r14
movq 0x8(%r14), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %rbx, %rcx
movl $0x1, %r8d
callq *0x48(%rax)
movq %rax, 0x18(%rbx)
movq 0x8(%r14), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %rbx, %rcx
movl $0x1, %r8d
callq *0x48(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x20(%rbx)
orb $0x4, 0x6(%rbx)
addq $0x18, %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: symbols_are_safe
static bool symbols_are_safe(s7_scheme *sc, s7_pointer args, s7_pointer e)
                {
                    s7_pointer p;
                    for (p = args; is_pair(p); p = cdr(p))
                    {
                        s7_pointer arg;
                        arg = car(p);
                        if ((is_normal_symbol(arg)) &&
                                (!arg_findable(sc, arg, e)))
                            return(false);
                    }
                    return(true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, (%rsi)
setne %bpl
jne 0xee62c
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%r14), %rsi
cmpb $0xa, (%rsi)
jne 0xee61e
testb $-0x80, 0x6(%rsi)
jne 0xee61e
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe9196
testb %al, %al
je 0xee62c
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
setne %bpl
je 0xee600
andb $0x1, %bpl
movl %ebp, %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: fx_subtract_T1
static s7_pointer fx_subtract_T1(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_outer_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(outlet(sc->envir)));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) - 1));
                    return(minus_c1(sc, x));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0xee6c6
movq 0x8(%rsi), %rax
leaq -0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xee6d5
leaq 0x60291(%rip), %rcx     # 0x14e950
movq -0x8(%rcx,%rax,8), %rax
jmp 0xee70e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc1efe
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xee6ed
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_add_T1
static s7_pointer fx_add_T1(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_outer_let_slots(sc, __func__, arg, cadr(arg));
                    x = slot_value(let_slots(outlet(sc->envir)));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) + 1));
                    return(g_add_x1_1(sc, x, cdr(arg))); /* arg=(+ x 1) */
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xb, (%rax)
jne 0xee751
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xee767
leaq 0x60206(%rip), %rcx     # 0x14e950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xee7a0
movq 0x10(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc1b57
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xee77f
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_Tca
static s7_pointer fx_c_Tca(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    p = cddr(arg);
                    check_outer_let_slots(sc, __func__, arg, cadr(arg));
                    set_car(sc->t3_3, fx_call(sc, cdr(p)));
                    set_car(sc->t3_1, slot_value(let_slots(outlet(sc->envir))));
                    set_car(sc->t3_2, 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 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x580(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rax
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_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_subtract_U1
static s7_pointer fx_subtract_U1(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x;
                    check_outer_next_let_slot(sc, __func__, arg, cadr(arg));
                    x = slot_value(next_slot(let_slots(outlet(sc->envir))));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) - 1));
                    return(minus_c1(sc, x));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0xee88a
movq 0x8(%rsi), %rax
leaq -0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xee899
leaq 0x600cd(%rip), %rcx     # 0x14e950
movq -0x8(%rcx,%rax,8), %rax
jmp 0xee8d2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc1efe
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xee8b1
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_add_U1
static s7_pointer fx_add_U1(s7_scheme *sc, s7_pointer arg) /* sub_t1 was not useful */
                {
                    s7_pointer x;
                    check_outer_next_let_slot(sc, __func__, arg, cadr(arg));
                    x = slot_value(next_slot(let_slots(outlet(sc->envir))));
                    if (is_t_integer(x))
                        return(make_integer(sc, integer(x) + 1));
                    return(g_add_x1_1(sc, x, cdr(arg)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0xb, (%rax)
jne 0xee919
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xee92f
leaq 0x6003e(%rip), %rcx     # 0x14e950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xee968
movq 0x10(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc1b57
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xee947
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_tT
static s7_pointer fx_num_eq_tT(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    check_let_slots(sc, __func__, arg, cadr(arg));
                    check_outer_let_slots(sc, __func__, arg, caddr(arg));
                    x = slot_value(let_slots(sc->envir));
                    y = slot_value(let_slots(outlet(sc->envir)));
                    if ((is_t_integer(x)) && (is_t_integer(y)))
                        return(make_boolean(sc, integer(x) == integer(y)));
                    return(num_eq_p_pp(sc, x, y));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq 0x10(%rcx), %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
cmpb $0xb, (%rsi)
jne 0x8fcc9
cmpb $0xb, (%rdx)
jne 0x8fcc9
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_Wt_direct
static s7_pointer fx_c_Wt_direct(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer old_e, W;
                    old_e = sc->envir;
                    sc->envir = outlet(outlet(old_e));
                    W = lookup(sc, cadr(arg));
                    sc->envir = old_e;
                    return(((s7_p_pp_t)opt2_direct(cdr(arg)))(sc, W, slot_value(let_slots(sc->envir))));
                }

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r8
movq 0x18(%rdx), %r9
movq 0x20(%r8), %rax
cmpq %rax, %r9
je 0xeeaf7
jle 0xeeaf2
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r9
cmpq %r9, %rax
jl 0xeeae5
cmpq %rax, %r9
jne 0xeeb19
movq 0x18(%r8), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rdx
movq 0x20(%rdx), %r8
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdx
movq %rax, %rsi
jmpq *%r8
cmpb $0x1c, (%rdx)
jne 0xeeb49
movq 0x8(%rdx), %r10
testq %r10, %r10
sete %r9b
je 0xeeb3b
cmpq %r8, 0x8(%r10)
je 0xeeb37
movq 0x18(%r10), %r10
jmp 0xeeb22
movq 0x10(%r10), %rax
testb %r9b, %r9b
je 0xeeaff
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xeeb1e
movq 0x10(%r8), %rax
cmpb $0x20, (%rax)
je 0xeeafb
xorl %eax, %eax
jmp 0xeeaff
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_closure
static s7_pointer make_closure(s7_scheme *sc, s7_pointer args, s7_pointer code, uint64_t type, int32_t arity)
    {
        /* this is called (almost?) every time a lambda form is evaluated, or during letrec, etc */
        s7_pointer x;
        new_cell(sc, x, (type | closure_bits(code)));
        closure_set_args(x, args);
        closure_set_body(x, code);
        if (is_pair(cdr(code))) set_closure_has_multiform(x); else set_closure_has_one_form(x);
        closure_set_let(x, sc->envir);
        closure_set_setter(x, sc->F);
        closure_set_arity(x, arity);
        sc->capture_let_counter++;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xefa01
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movabsq $0x12000000001000, %rcx # imm = 0x12000000001000
andq (%r15), %rcx
movq -0x8(%rax), %rax
orq %r13, %rcx
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x10(%r15), %rdx
cmpb $0x1, (%rdx)
movl $0x100, %edx            # imm = 0x100
movl $0x400, %esi            # imm = 0x400
cmoveq %rdx, %rsi
orq %rcx, %rsi
movq %rsi, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0x120(%r14), %rcx
movq %rcx, 0x20(%rax)
movl %ebx, 0x28(%rax)
incq 0x240(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: bind_symbol_with_setter
static s7_pointer bind_symbol_with_setter(s7_scheme *sc, opcode_t op, s7_pointer symbol, s7_pointer new_value)
                {
                    s7_pointer func;
                    func = g_setter(sc, set_plist_2(sc, symbol, sc->envir));
                    if (is_procedure_or_macro(func))
                    {
                        if (is_c_function(func))
                        {
                            set_car(sc->t2_1, symbol);
                            set_car(sc->t2_2, new_value);
                            new_value = c_function_call(func)(sc, sc->t2_1);
                        }
                        else
                        {
                            sc->args = list_2(sc, symbol, new_value);
                            push_stack(sc, op, sc->args, sc->code);
                            sc->code = func;
                            return(sc->no_value); /* this means the setter in set! needs to goto APPLY to get the new value */
                        }
                    }
                    return(new_value);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x708(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x710(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x708(%rdi), %rsi
callq 0x421fa
movq %rax, %r15
movzbl (%rax), %eax
leaq 0x64872(%rip), %rcx     # 0x154330
cmpb $0x0, (%rax,%rcx)
jne 0xefad5
leaq 0x648a5(%rip), %rcx     # 0x154370
cmpb $0x1, (%rax,%rcx)
jne 0xefbb0
cmpb $0x30, %al
jb 0xefb0d
movq 0x570(%rbx), %rax
movq %r13, 0x8(%rax)
movq 0x578(%rbx), %rax
movq %r12, 0x8(%rax)
movq 0x10(%r15), %rax
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xefb2c
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r13, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %rdx, 0x10(%rbx)
movq (%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq %r14, 0x18(%rax)
addq $0x20, 0x50(%rbx)
movq %r15, (%rbx)
movq 0x138(%rbx), %r12
movq %r12, %rax
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_dilambda_opt
static void set_dilambda_opt(s7_scheme *sc, s7_pointer form, opcode_t opt, s7_pointer expr)
                {
                    s7_pointer func;
                    func = lookup_checked(sc, car(expr));
                    if ((is_closure(func)) &&
                            (is_closure(closure_setter(func))) &&
                            (is_safe_closure(closure_setter(func))))
                    {
                        s7_pointer setter;
                        setter = closure_setter(func);
                        pair_set_syntax_op(form, opt);
                        if ((!(is_let(closure_let(setter)))) ||
                                (!(is_funclet(closure_let(setter)))))
                            make_funclet(sc, setter, car(expr), closure_let(setter));
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rcx), %rsi
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdx
movq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0xefbff
jle 0xefbfa
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jl 0xefbed
cmpq %rax, %rdx
jne 0xefc34
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xefc14
movq %r14, %rdi
callq 0xa2ee9
cmpb $0x28, (%rax)
jne 0xefc28
movq 0x20(%rax), %rsi
cmpb $0x28, (%rsi)
jne 0xefc28
testb $0x10, 0x1(%rsi)
jne 0xefc6f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x1c, (%rcx)
jne 0xefc62
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %dl
je 0xefc55
cmpq %rsi, 0x8(%rdi)
je 0xefc51
movq 0x18(%rdi), %rdi
jmp 0xefc3d
movq 0x10(%rdi), %rax
testb %dl, %dl
je 0xefc07
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xefc39
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xefc03
xorl %eax, %eax
jmp 0xefc07
movw %r12w, 0x4(%r15)
movw $0x201, (%r15)          # imm = 0x201
movq 0x18(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0xefc89
testb $0x20, 0x3(%rcx)
jne 0xefc28
movq 0x8(%rbx), %rdx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xeec4e
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mutable_method_or_bust
static s7_pointer mutable_method_or_bust(s7_scheme *sc, s7_pointer obj, s7_pointer method, s7_pointer args, uint8_t typ, int32_t num)
    {
        if (has_active_methods(sc, obj))
            return(find_and_apply_method(sc, find_let(sc, obj), method, args));
        if (type(obj) != typ)
            return(wrong_type_argument(sc, method, num, obj, typ));
        if (is_immutable(obj))
            return(immutable_object_error(sc, set_elist_3(sc, immutable_error_string, method, obj)));
        return(wrong_type_argument(sc, method, num, obj, typ));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rcx
movq %rdi, %rbx
testb $0x40, 0x3(%rsi)
je 0xeff6c
cmpb $0x1, 0x24c(%rbx)
jne 0xeff6c
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x9a55
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x967ca
cmpb %r8b, (%rcx)
jne 0xeff77
testb $0x1, 0x3(%rcx)
jne 0xeffa8
movq 0x8(%r14), %rsi
movq 0x5e9d6(%rip), %rdx     # 0x14e958
movq 0x140(%rbx), %rax
movzbl %r8b, %edi
leaq 0x62acc(%rip), %r8      # 0x152a60
movq (%r8,%rdi,8), %r9
movq %rbx, %rdi
movq %rax, %r8
popq %rbx
popq %r14
popq %r15
jmp 0xb31d
movq 0x629b9(%rip), %rax     # 0x152968
movq 0x6e8(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %r14, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e8(%rbx), %rdx
movq 0xea8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3b366