LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: dotimes
static bool dotimes(s7_scheme *sc, s7_pointer code, bool safe_case)
                {
                    s7_pointer body;
                    body = caddr(code);   /* here we assume one expr in body */
                    if (((is_syntactic_pair(body)) ||
                                (is_syntactic_symbol(car(body)))) &&
                            ((symbol_syntax_op_checked(body) == OP_LET) ||
                             (symbol_syntax_op(car(body)) == OP_LET_STAR)))
                        return(do_let(sc, sc->args, code) == goto_safe_do_end_clauses);
                    return(opt_dotimes(sc, cddr(code), code, safe_case));
                }

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x201, %eax            # imm = 0x201
je 0x16ef72
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movzwl (%rax), %eax
cmpl $0x20a, %eax            # imm = 0x20A
jne 0x16eff9
movq 0x10(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x201, %eax            # imm = 0x201
jne 0x16ef91
movq 0x10(%rsp), %rax
movzwl 0x4(%rax), %eax
movq %rax, 0x8(%rsp)
jmp 0x16efab
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x1ad, %rax            # imm = 0x1AD
je 0x16efd3
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpq $0x1af, 0x10(%rax)      # imm = 0x1AF
jne 0x16eff9
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0x1709b0
cmpl $0x4, %eax
sete %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x16f024
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rdx
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x16f030
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: opt_if_nbp_fs_nr
static s7_pointer opt_if_nbp_fs_nr(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 4, 1);
                    o1 = o->sc->opts[o->sc->pc];
                    if (!(o->v[2].b_pi_f(o->sc, o1->v[0].fp(o1), integer(slot_value(o->v[3].p))))) /* b_pi_fs */
                    {
                        o1 = o->sc->opts[++o->sc->pc];
                        o1->v[0].fp(o1);
                    }
                    return(NULL);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x68(%rcx), %rcx
movslq 0x2258(%rcx), %rcx
movq 0x2260(%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
testb $0x1, %al
jne 0x171c0e
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x68(%rcx), %rdx
movl 0x2258(%rdx), %ecx
addl $0x1, %ecx
movl %ecx, 0x2258(%rdx)
movslq %ecx, %rcx
movq 0x2260(%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1735e1
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x173556
movq 0x20(%rsp), %rcx
leaq 0xa2f34(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x1735cc
jmp 0x173558
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x17357c
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xb, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1735fa
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x110740
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x17369c
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x17369c
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x17367f
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x173690
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1736b5
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xba5c0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x173742
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x173722
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x173733
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1737dc
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x173799
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x10(%rsp), %rax
cvtsi2sdq 0x8(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x17377e
jp 0x17377e
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x17378e
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1737dc
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xa6cf6(%rip), %rax     # 0x21a4a0
testb $0x1, (%rax,%rcx)
jne 0x1737cb
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x173860
movq %rax, 0x30(%rsp)
jmp 0x1737dc
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: reuse_as_let
static s7_pointer reuse_as_let(s7_scheme *sc, s7_pointer frame, s7_pointer next_frame)
    {
        /* we're reusing frame here as a let -- it was probably a pair */
#if S7_DEBUGGING
        frame->debugger_bits = 0;
        if (not_in_heap(frame)) fprintf(stderr, "reusing an unheaped frame?\n");
#endif
        set_type(frame, T_LET | T_SAFE_PROCEDURE);
        let_set_slots(frame, slot_end(sc));
        set_outlet(frame, next_frame);
        let_id(frame) = ++sc->let_number;
        return(frame);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq $0x20001c, (%rax)       # imm = 0x20001C
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x250(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x250(%rax)
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: reuse_as_slot
static s7_pointer reuse_as_slot(s7_pointer slot, s7_pointer symbol, s7_pointer value)
    {
#if S7_DEBUGGING
        slot->debugger_bits = 0;
        if (not_in_heap(slot)) fprintf(stderr, "reusing an unheaped cell?\n");
#endif
        set_type(slot, T_SLOT);
        slot_set_symbol(slot, symbol);
        slot_set_value(slot, T_Pos(value));
        return(slot);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq $0x20, (%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: fx_tree_outer
static void fx_tree_outer(s7_scheme *sc, s7_pointer tree, s7_pointer var1, s7_pointer var2)
                {
                    /* if (is_pair(tree)) fprintf(stderr, "%s[%d]: %s %d %s %s\n", __func__, __LINE__, DISPLAY_80(tree), has_fx(tree), DISPLAY(var1), (var2) ? DISPLAY(var2) : ""); */
                    if ((!is_pair(tree)) ||
                            ((is_symbol(car(tree))) &&
                             (is_definer_or_binder(car(tree)))))
                        return;
                    if ((!has_fx(tree)) ||
                            (!fx_tree_out(sc, tree, var1, var2)))
                        fx_tree_outer(sc, car(tree), var1, var2);
                    fx_tree_outer(sc, cdr(tree), var1, var2);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x17467b
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x17467d
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movzwl 0x6(%rax), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x17467d
jmp 0x1746e5
movq 0x18(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1746ab
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x18ab10
testb $0x1, %al
jne 0x1746c8
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x174630
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x174630
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x174745
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x17474a
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movzwl 0x6(%rax), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x17474a
jmp 0x1747d0
movq 0x28(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x174782
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x18b810
testb $0x1, %al
jne 0x1747a9
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x1746f0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x1746f0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3a070
cmpq $0x3, %rax
jne 0x174912
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x174822
jmp 0x174912
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x801, %eax            # imm = 0x801
jne 0x174910
movq 0x8(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x9, %eax
jne 0x174875
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
je 0x174904
movq 0x8(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x3, %eax
jne 0x1748da
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1748da
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1748da
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x1a60(%rcx), %rax
je 0x174904
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x1a80(%rcx), %rax
je 0x174904
movq 0x8(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0xb, %eax
jne 0x174910
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0x174910
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x17491b
jmp 0x174912
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzwl (%rax), %ecx
xorl %eax, %eax
cmpl $0x801, %ecx            # imm = 0x801
movb %al, -0x11(%rsp)
jne 0x174a84
movq -0x10(%rsp), %rax
movzwl 0x4(%rax), %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
movb %al, -0x11(%rsp)
jl 0x174a84
movq -0x10(%rsp), %rax
movzwl 0x4(%rax), %ecx
xorl %eax, %eax
cmpl $0x9e, %ecx
movb %al, -0x11(%rsp)
jge 0x174a84
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x11(%rsp)
jne 0x174a84
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x11(%rsp)
je 0x174a84
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rsp), %rdx
movb $0x1, %al
cmpq 0x1c60(%rdx), %rcx
movb %al, -0x12(%rsp)
je 0x174a7c
movq -0x10(%rsp), %rax
movzwl 0x4(%rax), %ecx
movb $0x1, %al
cmpl $0x7, %ecx
movb %al, -0x12(%rsp)
je 0x174a7c
movq -0x10(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x12(%rsp)
movb -0x12(%rsp), %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x174dd9
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xde160
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x174d60
movq 0x40(%rsp), %rdi
callq 0xc670
movq 0x40(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x174cfe
movq 0x40(%rsp), %rax
movq 0x4d8(%rax), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x17fa61
movq 0x8(%rsp), %rcx
leaq 0x96a2a(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x17face
cmpq $0x20000000, 0x8(%rsp)  # imm = 0x20000000
jne 0x17fa7a
movq 0x9c465(%rip), %rax     # 0x21bed8
movq %rax, 0x10(%rsp)
jmp 0x17face
cmpq $0x40000000, 0x8(%rsp)  # imm = 0x40000000
jne 0x17fa93
movq 0xa54c4(%rip), %rax     # 0x224f50
movq %rax, 0x10(%rsp)
jmp 0x17face
cmpq $-0x1, 0x8(%rsp)
jne 0x17faa9
movq 0xa54a6(%rip), %rax     # 0x224f48
movq %rax, 0x10(%rsp)
jmp 0x17face
cmpq $-0x2, 0x8(%rsp)
jne 0x17fabf
movq 0xa54a0(%rip), %rax     # 0x224f58
movq %rax, 0x10(%rsp)
jmp 0x17face
movq 0x8(%rsp), %rdi
callq 0x18aac0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x17fb47
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x15cfb0
testb $0x1, %al
jne 0x17fb2a
jmp 0x17fb35
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x17fb37
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x17fb04
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: vars_syntax_ok
static bool vars_syntax_ok(s7_pointer vars)
                {
                    s7_pointer p;
                    for (p = vars; is_pair(p); p = cdr(p))
                    {
                        s7_pointer var;
                        var = car(p);
                        if ((!is_pair(var)) ||
                                (!is_symbol(car(var))) ||
                                (!is_pair(cdr(var))))
                            return(false);
                    }
                    return(true);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x17fbc2
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x17fba9
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x17fba9
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x17fbb0
movb $0x0, -0x1(%rsp)
jmp 0x17fbc7
jmp 0x17fbb2
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x17fb5f
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x17fc6a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x17fc58
movq (%rsp), %rax
movq (%rax), %rax
andq $0x400000, %rax         # imm = 0x400000
cmpq $0x0, %rax
jne 0x17fc58
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
xorl %r8d, %r8d
callq 0x174df0
cmpl $0x2, %eax
jne 0x17fc58
movb $0x0, 0x37(%rsp)
jmp 0x17fc6f
jmp 0x17fc5a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x17fbf1
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_not_h_optimized
static bool is_not_h_optimized(s7_pointer p)
    {
        return((is_optimized(p)) &&
                ((optimize_op(p) & 1) == 0) &&
                (optimize_op(p) < OP_S) &&
                (optimize_op(p) > OP_GC_PROTECT));
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzwl (%rax), %ecx
xorl %eax, %eax
cmpl $0x801, %ecx            # imm = 0x801
movb %al, -0x9(%rsp)
jne 0x18223c
movq -0x8(%rsp), %rax
movzwl 0x4(%rax), %ecx
andl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rsp)
jne 0x18223c
movq -0x8(%rsp), %rax
movzwl 0x4(%rax), %ecx
xorl %eax, %eax
cmpl $0x16a, %ecx            # imm = 0x16A
movb %al, -0x9(%rsp)
jge 0x18223c
movq -0x8(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x1, %eax
setg %al
movb %al, -0x9(%rsp)
movb -0x9(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_h_optimized
static bool is_h_optimized(s7_pointer p)
    {
        return((is_optimized(p)) &&
                ((optimize_op(p) & 1) != 0) &&
                (optimize_op(p) < OP_S) &&
                (optimize_op(p) > OP_GC_PROTECT));
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzwl (%rax), %ecx
xorl %eax, %eax
cmpl $0x801, %ecx            # imm = 0x801
movb %al, -0x9(%rsp)
jne 0x1822ac
movq -0x8(%rsp), %rax
movzwl 0x4(%rax), %ecx
andl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rsp)
je 0x1822ac
movq -0x8(%rsp), %rax
movzwl 0x4(%rax), %ecx
xorl %eax, %eax
cmpl $0x16a, %ecx            # imm = 0x16A
movb %al, -0x9(%rsp)
jge 0x1822ac
movq -0x8(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x1, %eax
setg %al
movb %al, -0x9(%rsp)
movb -0x9(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17fae0
cmpl 0x10(%rsp), %eax
jne 0x1823d2
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x164800
movslq 0x10(%rsp), %rcx
leaq 0x94122(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rcx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
jmp 0x182387
movq 0x20(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
addl $0x10c, %eax            # imm = 0x10C
movw %ax, %cx
movq 0x20(%rsp), %rax
movw %cx, 0x4(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, 0x34(%rsp)
jmp 0x1823da
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq %r9, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x182c19
jmp 0x182b53
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, 0x27(%rsp)
je 0x182b96
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
sete %al
movb %al, 0x27(%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movb 0x27(%rsp), %r8b
leaq -0x7cfb1(%rip), %rcx    # 0x105c00
leaq -0x25a98(%rip), %rax    # 0x15d120
testb $0x1, %r8b
cmovneq %rax, %rcx
callq 0x103260
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x28(%rsp)
je 0x182bf2
movq 0x30(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x6(%rax)
jmp 0x182c02
movq 0x30(%rsp), %rax
movzwl 0x6(%rax), %ecx
andl $-0x5, %ecx
movw %cx, 0x6(%rax)
jmp 0x182c04
jmp 0x182c06
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x182b40
jmp 0x182c1b
movslq 0x44(%rsp), %rdi
callq 0x17fa30
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
jmp 0x182c4d
movq 0x50(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movw %ax, %cx
movq 0x50(%rsp), %rax
movw %cx, 0x4(%rax)
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x18(%rax)
xorl %eax, %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x182cc7
movb $0x0, 0x27(%rsp)
jmp 0x182d38
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x178880
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x182d33
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, 0x7(%rsp)
jl 0x182d27
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x200000, %rax         # imm = 0x200000
cmpq $0x0, %rax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x182d38
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movb $0x0, 0x46(%rsp)
movl $0x3, 0x2c(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1839d2
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x183978
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
testb $0x1, 0x47(%rsp)
movb %al, 0x2b(%rsp)
je 0x183935
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
movb %al, 0x2b(%rsp)
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movb 0x2b(%rsp), %al
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x1879d0
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0x1879a0
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x183976
movl $0x0, 0x64(%rsp)
jmp 0x1839f7
jmp 0x183978
movq 0x38(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x1839bd
testb $0x1, 0x46(%rsp)
je 0x1839b1
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
jne 0x1839af
movl $0x0, 0x64(%rsp)
jmp 0x1839f7
jmp 0x1839b1
movb 0x46(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x46(%rsp)
jmp 0x1839bf
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x1838bc
movq 0x38(%rsp), %rax
movq 0x58(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x1839ef
movl $0x0, 0x64(%rsp)
jmp 0x1839f7
movl 0x2c(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq %r9, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x18a939
jmp 0x18a873
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, 0x27(%rsp)
je 0x18a8b6
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
sete %al
movb %al, 0x27(%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movb 0x27(%rsp), %r8b
leaq -0x84cd1(%rip), %rcx    # 0x105c00
leaq -0x2d7b8(%rip), %rax    # 0x15d120
testb $0x1, %r8b
cmovneq %rax, %rcx
callq 0x103260
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x28(%rsp)
je 0x18a912
movq 0x30(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x6(%rax)
jmp 0x18a922
movq 0x30(%rsp), %rax
movzwl 0x6(%rax), %ecx
andl $-0x5, %ecx
movw %cx, 0x6(%rax)
jmp 0x18a924
jmp 0x18a926
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x18a860
jmp 0x18a93b
movslq 0x44(%rsp), %rdi
callq 0x17fa30
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
jmp 0x18a96d
movq 0x50(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
orq $0x800, %rcx            # imm = 0x800
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movw %ax, %cx
movq 0x50(%rsp), %rax
movw %cx, 0x4(%rax)
jmp 0x18a99e
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x44(%rsp), %edx
movq 0x50(%rsp), %rcx
movl $0x1, %r8d
callq *%rax
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl 0x44(%rsp), %edx
movq 0x50(%rsp), %rcx
movl $0x1, %r8d
callq *%rax
movq 0x10(%rax), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x50(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x6(%rax)
jmp 0x18aa19
xorl %eax, %eax
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x18aaa9
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x18aa97
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x18aa97
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x180030
testb $0x1, %al
jne 0x18aa97
movb $0x0, 0x37(%rsp)
jmp 0x18aaae
jmp 0x18aa99
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x18aa3d
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_integer_unchecked
static s7_pointer make_permanent_integer_unchecked(s7_int i)
    {
        s7_pointer p;
        p = (s7_pointer)calloc(1, sizeof(s7_cell));
        set_type_bit(p, T_IMMUTABLE | T_INTEGER | T_UNHEAP);
        integer(p) = i;
        return(p);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x9360
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movabsq $0x400000000100000b, %rcx # imm = 0x400000000100000B
orq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x18b03d
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x18afb2
movq 0x20(%rsp), %rcx
leaq 0x8b4d8(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x18b028
jmp 0x18afb4
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x18afd8
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xb, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x18b051
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x111230
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x18b15d
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x18b0d2
movq 0x20(%rsp), %rcx
leaq 0x8b3b8(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x18b148
jmp 0x18b0d4
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x18b0f8
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xb, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x18b17a
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x110740
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x590(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq 0x580(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rsp), %rax
movq 0x588(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x580(%rcx), %rsi
callq *%rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_Ti
static s7_pointer fx_num_eq_Ti(s7_scheme *sc, s7_pointer arg)
                {
                    s7_int y;
                    s7_pointer val, args;
                    args = cdr(arg);
                    check_outer_let_slots(sc, __func__, arg, cadr(arg));
                    val = slot_value(let_slots(outlet(sc->envir)));
                    y = integer(cadr(args));
                    if (is_t_integer(val))
                        return(make_boolean(sc, integer(val) == y));
                    return(fx_num_eq_xi_1(sc, args, val, y));
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x18b2e6
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x18b2cb
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x18b2db
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x18b304
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x111d70
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop