LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movb (%r14), %r12b
cmpb $0x1, %r12b
jne 0xb1d8a
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xb1d84
testb $0x40, 0x2(%rsi)
jne 0xb1d84
movq %r15, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xac020
cmpl $0x2, %eax
je 0xb1d8a
movq 0x10(%r14), %r14
jmp 0xb1d4f
cmpb $0x1, %r12b
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0xa, (%rsi)
jne 0xb1e12
movl 0xa88(%r14), %eax
movl %eax, 0x2c(%rbx)
movl 0xa8c(%r14), %eax
movq 0x8(%rbx), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xb1dec
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, %r15
jmp 0xb1f25
movq %r15, 0x4d8(%r14)
movzbl (%rbx), %eax
cmpl $0x1, %eax
jne 0xb1eb9
movq 0x8(%rbx), %r12
movb (%r12), %al
cmpb $0x1, %al
jne 0xb1e3a
movq 0x8(%r12), %r12
movb (%r12), %al
cmpb $0xa, %al
jne 0xb1eb0
testb $-0x80, 0x6(%r12)
jne 0xb1eb0
movl 0xa88(%r14), %eax
movl %eax, 0x2c(%r12)
movl 0xa8c(%r14), %eax
movq 0x8(%r12), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x4d8(%r14), %r13
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xb1e8b
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r12, 0x8(%r15)
movq %r13, 0x10(%r15)
movq %r15, 0x4d8(%r14)
movq 0x10(%rbx), %rbx
jmp 0xb1e19
cmpl $0xa, %eax
jne 0xb1f25
movl 0xa88(%r14), %eax
movl %eax, 0x2c(%rbx)
movl 0xa8c(%r14), %eax
movq 0x8(%rbx), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0xc(%rcx)
movq 0x4d8(%r14), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xb1f00
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %rbx, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r15, 0x4d8(%r14)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpw $0x801, (%rdi)          # imm = 0x801
jne 0xb26ea
movzwl 0x4(%rdi), %eax
testb $0x1, %al
sete %cl
addl $-0x2, %eax
cmpw $0x168, %ax             # imm = 0x168
setb %al
andb %cl, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpw $0x801, (%rdi)          # imm = 0x801
jne 0xb2706
movl 0x4(%rdi), %ecx
movl %ecx, %eax
addl $-0x2, %eax
cmpw $0x168, %ax             # imm = 0x168
setb %al
andb %cl, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb1d0d
cmpl %r15d, %eax
jne 0xb2775
movq 0x10(%r14), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0xa5dd4
movslq %r15d, %rax
leaq 0x63208(%rip), %rcx     # 0x115950
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_O2/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 -0x2506c(%rip), %r9     # 0x8d7e1
cmpq %r9, %rcx
je 0xb2873
movq 0x20(%rdx), %r8
addq $0x8, %rdx
cmpq %r9, %r8
je 0xb2879
leaq -0x20fff(%rip), %r9     # 0x91867
cmpq %r9, %rcx
je 0xb2882
cmpq %r9, %r8
je 0xb2888
xorl %eax, %eax
retq
movw $0x72, %cx
jmp 0xb289a
movw $0x70, %cx
movq %rdx, %rax
jmp 0xb289a
movw $0x72, %cx
jmp 0xb288f
movw $0x70, %cx
movq %rdx, %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq $0x8, %rax
movq (%rax), %rax
movq %rax, 0x28(%rdi)
movq (%rdi), %rax
movq %rax, %rdx
andq $-0x40001, %rdx         # imm = 0xFFFBFFFF
movq %rdx, (%rdi)
orl $0x800, %eax            # imm = 0x800
movw %ax, (%rdi)
movzwl %cx, %eax
addl %esi, %eax
movw %ax, 0x4(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rcx, %r12
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
leaq 0x10(%rdx), %rbx
leaq -0x10455(%rip), %r15    # 0xa26dd
leaq -0x2539e(%rip), %rbp    # 0x8d79b
movq (%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0xb2b7e
movb (%r12), %al
decb %al
cmpb $0x2, %al
movq %rbp, %rcx
cmovbq %r15, %rcx
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x8c0ba
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)
addq $0x10, %rbx
jmp 0xb2b39
movslq 0x4(%rsp), %rdi
callq 0xb1cb6
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_O2/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 0xb2be7
pushq %rax
callq 0xb1bd4
cmpb $0x20, (%rax)
jne 0xb2bea
movq 0x10(%rax), %rax
cmpb $0x30, (%rax)
jb 0xb2bea
movb 0x2(%rax), %al
andb $0x20, %al
shrb $0x5, %al
jmp 0xb2bec
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, (%rsp)
pushq $0x3
popq %r13
xorl %ebx, %ebx
movq %rdx, %r15
movq %rdx, %r12
xorl %ebp, %ebp
cmpb $0x1, (%r15)
jne 0xb5a94
movq 0x8(%r15), %rdx
cmpb $0x1, (%rdx)
jne 0xb5a77
movl $0x0, %eax
cmpb $0x0, 0xc(%rsp)
je 0xb5a5a
movq 0x10(%r15), %rax
movq (%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
movzbl %al, %ecx
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb5aba
cmpl %eax, %r13d
cmovael %eax, %r13d
testl %r13d, %r13d
je 0xb5aa9
cmpq %r14, %r15
je 0xb5a8e
testb $0x1, %bl
je 0xb5a8b
movq 0x10(%r12), %r12
cmpq %r12, %r15
je 0xb5aa7
xorb $0x1, %bl
movq 0x10(%r15), %r15
jmp 0xb5a2d
xorl %ebp, %ebp
movq (%rsp), %rax
cmpq 0x110(%rax), %r15
cmovel %r13d, %ebp
jmp 0xb5aa9
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 %rcx, %r13
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
leaq 0x10(%rdx), %r12
leaq -0x13f93(%rip), %rbp    # 0xa26dd
leaq -0x28edc(%rip), %r14    # 0x8d79b
movq (%r12), %r12
cmpb $0x1, (%r12)
jne 0xb66c4
movb (%r13), %al
decb %al
cmpb $0x2, %al
movq %r14, %rcx
cmovbq %rbp, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x8c0ba
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)
addq $0x10, %r12
jmp 0xb6677
movslq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0xb1cb6
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
pushq $0x1
popq %rbp
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %rbx, %rcx
movl %ebp, %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 %ebp, %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_O2/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
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb (%r14), %bpl
cmpb $0x1, %bpl
jne 0xb6784
movq 0x8(%r14), %rsi
cmpb $0xa, (%rsi)
jne 0xb677e
testb $-0x80, 0x6(%rsi)
jne 0xb677e
movq %r15, %rdi
movq %rbx, %rdx
callq 0xb1f32
testb %al, %al
je 0xb6784
movq 0x10(%r14), %r14
jmp 0xb6757
cmpb $0x1, %bpl
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x8360
movabsq $0x400000000100000b, %rcx # imm = 0x400000000100000B
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb6841
movq 0x8(%rsi), %rax
leaq -0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xb6850
leaq 0x5f116(%rip), %rcx     # 0x115950
movq -0x8(%rcx,%rax,8), %rax
jmp 0xb6889
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92479
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb686f
movq %rbx, %rdi
callq 0x9c27
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_O2/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 0xb68cc
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xb68e2
leaq 0x5f08b(%rip), %rcx     # 0x115950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xb691b
movq 0x10(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x920da
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb6901
movq %rbx, %rdi
callq 0x9c27
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_O2/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 0xb6a05
movq 0x8(%rsi), %rax
leaq -0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xb6a14
leaq 0x5ef52(%rip), %rcx     # 0x115950
movq -0x8(%rcx,%rax,8), %rax
jmp 0xb6a4d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92479
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb6a33
movq %rbx, %rdi
callq 0x9c27
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_O2/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 0xb6a94
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xb6aaa
leaq 0x5eec3(%rip), %rcx     # 0x115950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xb6ae3
movq 0x10(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x920da
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb6ac9
movq %rbx, %rdi
callq 0x9c27
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_O2/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 0x6e8d2
cmpb $0xb, (%rdx)
jne 0x6e8d2
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_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq %r15, 0x8(%r14)
movq 0x10(%rbx), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%r15), %rdx
movq 0x10(%rdx), %rdx
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: add_permanent_let_or_slot
static void add_permanent_let_or_slot(s7_scheme *sc, s7_pointer obj)
    {
        gc_obj *g;
        g = (gc_obj *)malloc(sizeof(gc_obj));
        g->p = obj;
        g->nxt = sc->permanent_lets;
        sc->permanent_lets = g;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x8480
movq %rbx, (%rax)
movq 0xc8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0xc8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: do_step1
static bool do_step1(s7_scheme *sc)
                {
                    /* on each iteration, each arg incr expr is evaluated and the value placed in caddr while we cdr down args */
                    while (true)
                    {
                        s7_pointer code;
                        if (is_null(sc->args))
                        {
                            s7_pointer x;
                            for (x = sc->code; is_pair(x); x = cdr(x)) /* sc->code here is the original sc->args list */
                            {
                                slot_set_value(car(x), slot_pending_value(car(x)));
                                slot_clear_has_pending_value(car(x));
                            }
                            pop_stack_no_op(sc);
                            return(true);
                        }
                        code = slot_expression(car(sc->args));
                        if (has_fx(code))
                        {
                            sc->value = fx_call(sc, code);
#if S7_DEBUGGING
                            /* can values happen here even in error? */
                            if (is_multiple_value(sc->value))
                                fprintf(stderr, "got multiple values! %s\n", DISPLAY(sc->value));
#endif
                            slot_set_pending_value(car(sc->args), sc->value);
                            sc->args = cdr(sc->args);                   /* go to next step var */
                        }
                        else
                        {
                            push_stack(sc, OP_DO_STEP2, sc->args, sc->code);
                            sc->code = car(code);
                            return(false);
                        }
                    }
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x110(%rbx), %rcx
cmpq %rcx, %rax
je 0xb6ce4
movq 0x8(%rax), %rdx
movq 0x28(%rdx), %rdx
testb $0x4, 0x6(%rdx)
je 0xb6d29
movq 0x8(%rdx), %rsi
movq %rbx, %rdi
callq *0x20(%rdx)
movq %rax, 0x20(%rbx)
movq 0x10(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
orq $0x20000000, (%rax)     # imm = 0x20000000
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0xb6c93
movq %rbx, %rdx
movq (%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0xb6d0c
movq 0x8(%rdx), %rsi
movq 0x20(%rsi), %rdi
movq %rdi, 0x10(%rsi)
movq 0x8(%rdx), %rsi
andq $-0x20000001, (%rsi)    # imm = 0xDFFFFFFF
addq $0x10, %rdx
jmp 0xb6ce7
movq 0x50(%rbx), %rdx
leaq -0x20(%rdx), %rsi
movq %rsi, 0x50(%rbx)
movups -0x20(%rdx), %xmm0
movups %xmm0, (%rbx)
movq -0x10(%rdx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0xb6d63
movq (%rbx), %rsi
movq 0x50(%rbx), %rdi
movq %rsi, (%rdi)
movq 0x8(%rbx), %rsi
movq 0x50(%rbx), %rdi
movq %rsi, 0x8(%rdi)
movq 0x10(%rbx), %rsi
movq 0x50(%rbx), %rdi
movq %rsi, 0x10(%rdi)
movq 0x50(%rbx), %rsi
movq $0x1e8, 0x18(%rsi)      # imm = 0x1E8
addq $0x20, 0x50(%rbx)
movq 0x8(%rdx), %rdx
movq %rdx, (%rbx)
cmpq %rcx, %rax
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x325c4
movq %rax, %r15
movzbl (%rax), %eax
leaq 0x63ba0(%rip), %rcx     # 0x11b330
cmpb $0x0, (%rax,%rcx)
jne 0xb77a7
leaq 0x63bd3(%rip), %rcx     # 0x11b370
cmpb $0x1, (%rax,%rcx)
jne 0xb7882
cmpb $0x30, %al
jb 0xb77df
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 0xb7805
movq %rbx, %rdi
callq 0x9c27
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_O2/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 %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rcx), %r13
movq %r13, %rsi
callq 0x7d158
testq %rax, %rax
jne 0xb78c5
movq %r14, %rdi
movq %r13, %rsi
callq 0x7d1b2
cmpb $0x28, (%rax)
jne 0xb78d9
movq 0x20(%rax), %rsi
cmpb $0x28, (%rsi)
jne 0xb78d9
testb $0x10, 0x1(%rsi)
jne 0xb78e3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movw %r12w, 0x4(%r15)
movw $0x201, (%r15)          # imm = 0x201
movq 0x18(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0xb78fd
testb $0x20, 0x3(%rcx)
jne 0xb78d9
movq 0x8(%rbx), %rdx
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb6d6b
// File: /workspace/github_c_makefile_star2_O2/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
movq (%rsi), %rax
btl $0x1e, %eax
jae 0xb7b9f
cmpb $0x1, 0x24c(%rbx)
jne 0xb7b9f
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x88f3
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x73dc9
cmpb %r8b, %al
jne 0xb7baa
btl $0x18, %eax
jb 0xb7bdb
movq 0x8(%r14), %rsi
movq 0x5dda3(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %rax
movzbl %r8b, %edi
leaq 0x61e99(%rip), %r8      # 0x119a60
movq (%r8,%rdi,8), %r9
movq %rbx, %rdi
movq %rax, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x9bbb
movq 0x61d86(%rip), %rax     # 0x119968
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), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x972b
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: check_let_a_body
static void check_let_a_body(s7_scheme *sc, s7_pointer form)
                {
                    if (is_fxable(sc, cadr(sc->code)))
                    {
                        annotate_arg(sc, cdr(sc->code), set_plist_1(sc, caaar(sc->code))); /* was sc->envir) ? */
                        fx_tree(sc, cdr(sc->code), caaar(sc->code), NULL);
                        pair_set_syntax_op(form, OP_LET_A_A_OLD);
                    }
                    else
                    {
                        if (is_pair(cadr(sc->code)))
                            pair_set_syntax_op(form, OP_LET_A_P_OLD);
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r13
movq 0x10(%r13), %r15
movq 0x8(%r15), %r12
movq %r12, %rsi
callq 0xa2689
testb %al, %al
je 0xb8a1a
movq 0x8(%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x700(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%r14), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xa26b2
movq (%r14), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdi
movq 0x8(%rcx), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0xa26f4
movw $0x25e, %ax             # imm = 0x25E
jmp 0xb8a25
movw $0x25c, %ax             # imm = 0x25C
cmpb $0x1, (%r12)
jne 0xb8a2e
movw %ax, 0x4(%rbx)
movw $0x201, (%rbx)          # imm = 0x201
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_let_opssq
static inline void op_let_opssq(s7_scheme *sc)
                {
                    s7_pointer largs, in_val;
                    start_let(sc);
                    largs = T_Pair(opt2_pair(sc->code));                              /* cadr(caar(sc->code)); */
                    in_val = lookup(sc, cadr(largs));
                    set_car(sc->t2_2, lookup(sc, opt3_sym(cdr(sc->code)))); /* caddr(largs)); */
                    set_car(sc->t2_1, in_val);
                    sc->value = c_call(largs)(sc, sc->t2_1);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x28(%rdi)
movq 0x10(%rax), %r15
movq %r15, (%rdi)
movq 0x20(%r15), %r12
movq 0x10(%r12), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq %rax, %r14
movq 0x10(%r15), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
movq 0x578(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x570(%rbx), %rax
movq %r14, 0x8(%rax)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r12)
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: op_let_opassq
static inline void op_let_opassq(s7_scheme *sc)
                {
                    s7_pointer largs, in_val, lst;
                    start_let(sc);
                    largs = T_Pair(opt2_pair(sc->code));                              /* cadr(caar(sc->code)); */
                    in_val = lookup(sc, cadr(largs));
                    lst = lookup(sc, opt3_sym(cdr(sc->code)));
                    if (is_pair(lst))
                        sc->value = s7_assq(sc, in_val, lst);
                    else
                    {
                        if (is_null(lst))
                            sc->value = sc->F;
                        else sc->value = g_assq(sc, set_plist_2(sc, in_val, lst));
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x28(%rdi)
movq 0x10(%rax), %r15
movq %r15, (%rdi)
movq 0x20(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x7d158
movq %rax, %r14
movq 0x10(%r15), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x7d158
cmpb $0x1, (%rax)
jne 0xb8afa
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2db7b
jmp 0xb8b31
cmpq 0x110(%rbx), %rax
je 0xb8b2a
movq 0x708(%rbx), %rcx
movq %r14, 0x8(%rcx)
movq 0x710(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x708(%rbx), %rsi
movq %rbx, %rdi
callq 0x5ea5b
jmp 0xb8b31
movq 0x120(%rbx), %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: activate_permanent_let_star
static s7_pointer activate_permanent_let_star(s7_scheme *sc, s7_pointer frame, s7_pointer vars)
    {
        s7_pointer slot, var;
        let_id(frame) = ++sc->let_number;
        set_outlet(frame, sc->envir);
        sc->envir = frame;
        for (var = vars, slot = let_slots(frame); is_pair(var); var = cdr(var), slot = next_slot(slot))
        {
            slot_set_value(slot, fx_call(sc, cdar(var)));
            symbol_set_local(caar(var), sc->let_number, slot);
        }
        return(frame);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x250(%rdi), %rax
incq %rax
movq %rax, 0x250(%rdi)
leaq 0x8(%rsi), %r12
movq %rax, 0x18(%rsi)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdi)
cmpb $0x1, (%r14)
jne 0xb8bc6
movq (%r12), %r12
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq *0x20(%rax)
movq %rax, 0x10(%r12)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq %r12, 0x18(%rax)
movq 0x250(%r15), %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
incl 0x28(%rax)
movq 0x10(%r14), %r14
addq $0x18, %r12
jmp 0xb8b71
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fx_cond_value
static inline bool fx_cond_value(s7_scheme *sc, s7_pointer p)
                {
                    if (has_fx(p))
                    {
                        sc->value = fx_call(sc, p);
                        return(true);
                    }
                    sc->code = car(p);
                    return(false);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r14
movzwl 0x6(%rsi), %ebx
testb $0x4, %bl
je 0xb8c42
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq *0x20(%rax)
movq %rax, 0x20(%r14)
jmp 0xb8c49
movq 0x8(%rax), %rax
movq %rax, (%r14)
andl $0x4, %ebx
shrl $0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: tree_descend
static s7_pointer tree_descend(s7_scheme *sc, s7_pointer p, uint32_t line)
                {
                    s7_pointer tp;
                    if (!is_pair(p)) return(NULL);
                    if (has_line_number(p))
                    {
                        uint32_t x;
                        x = (uint32_t)pair_line_number(p);
                        if (x > 0)
                        {
                            if (line == 0) /* first line number we encounter will be the current reader location (i.e. the end of the form) */
                                line = x;
                            else
                            {
                                if (x < line)
                                    return(p);
                            }
                        }
                    }
                    tp = tree_descend(sc, car(p), line);
                    if (tp) return(tp);
                    return(tree_descend(sc, cdr(p), line));
                }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, (%rbx)
jne 0xb8ee9
testb $0x4, 0x2(%rbx)
je 0xb8ed3
movl 0x2c(%rbx), %eax
testl %eax, %eax
je 0xb8ed3
testl %ebp, %ebp
je 0xb8ed1
cmpl %ebp, %eax
jae 0xb8ed3
jmp 0xb8ef0
movl %eax, %ebp
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq 0xb8ead
testq %rax, %rax
jne 0xb8eed
movq 0x10(%rbx), %rbx
jmp 0xb8eb5
xorl %ebx, %ebx
jmp 0xb8ef0
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: back_up_stack
static void back_up_stack(s7_scheme *sc)
                {
                    opcode_t top_op;
                    top_op = stack_op(sc->stack, s7_stack_top(sc) - 1);
                    if (top_op == OP_READ_DOT)
                    {
                        pop_stack(sc);
                        top_op = stack_op(sc->stack, s7_stack_top(sc) - 1);
                    }
                    if ((top_op == OP_READ_VECTOR) ||
                            (top_op == OP_READ_BYTE_VECTOR) ||
                            (top_op == OP_READ_INT_VECTOR) ||
                            (top_op == OP_READ_FLOAT_VECTOR))
                    {
                        pop_stack(sc);
                        top_op = stack_op(sc->stack, s7_stack_top(sc) - 1);
                    }
                    if (top_op == OP_READ_QUOTE)
                        pop_stack(sc);
                }

// Assembly:
movq 0x38(%rdi), %rdx
movq 0x48(%rdi), %rcx
movq 0x10(%rdx), %rsi
movq 0x50(%rdi), %rax
movq %rax, %r8
subq %rcx, %r8
movq -0x8(%rsi,%r8), %rsi
cmpq $0x1d3, %rsi            # imm = 0x1D3
jne 0xb8f44
leaq -0x20(%rax), %rsi
movq %rsi, 0x50(%rdi)
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x10(%rdx), %r8
movq %rsi, %rax
subq %rcx, %rsi
movq -0x8(%r8,%rsi), %rsi
movq %rsi, %r8
andq $-0x4, %r8
cmpq $0x1d8, %r8             # imm = 0x1D8
jne 0xb8f7a
leaq -0x20(%rax), %rsi
movq %rsi, 0x50(%rdi)
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x10(%rdx), %rdx
movq %rsi, %rax
subq %rcx, %rsi
movq -0x8(%rdx,%rsi), %rsi
cmpq $0x1d4, %rsi            # imm = 0x1D4
je 0xb8f84
retq
leaq -0x20(%rax), %rcx
movq %rcx, 0x50(%rdi)
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm0, (%rdi)
movups %xmm1, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: is_simple_code
static bool is_simple_code(s7_scheme *sc, s7_pointer form)
                {
                    s7_pointer tmp, slow;
                    for (tmp = form, slow = form; is_pair(tmp); tmp = cdr(tmp), slow = cdr(slow))
                    {
                        if (is_pair(car(tmp)))
                        {
                            if (!is_simple_code(sc, car(tmp)))
                                return(false);
                        }
                        else
                        {
                            if ((car(tmp) == sc->unquote_symbol) ||
                                    ((is_null(car(tmp))) && (is_null(cdr(tmp)))))
                                return(false);
                        }
                        tmp = cdr(tmp);
                        if (!is_pair(tmp)) return(is_null(tmp));
                        if (tmp == slow) return(false);
                        if (is_pair(car(tmp)))
                        {
                            if (!is_simple_code(sc, car(tmp)))
                                return(false);
                        }
                        else
                        {
                            if ((car(tmp) == sc->unquote_symbol) ||
                                    ((is_null(car(tmp))) && (is_null(cdr(tmp)))))
                                return(false);
                        }
                    }
                    return(is_null(tmp));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
cmpb $0x1, (%rbx)
jne 0xb9560
movq 0x8(%rbx), %rsi
cmpb $0x1, (%rsi)
jne 0xb94fd
movq %r14, %rdi
callq 0xb94d3
testb %al, %al
jne 0xb9515
jmp 0xb955c
cmpq 0x17b8(%r14), %rsi
je 0xb955c
cmpq 0x110(%r14), %rsi
jne 0xb9515
cmpq %rsi, 0x10(%rbx)
je 0xb955c
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
jne 0xb9560
cmpq %r15, %rbx
je 0xb955c
movq 0x8(%rbx), %rsi
cmpb $0x1, (%rsi)
jne 0xb953a
movq %r14, %rdi
callq 0xb94d3
testb %al, %al
jne 0xb9552
jmp 0xb955c
cmpq 0x17b8(%r14), %rsi
je 0xb955c
cmpq 0x110(%r14), %rsi
jne 0xb9552
cmpq %rsi, 0x10(%rbx)
je 0xb955c
movq 0x10(%rbx), %rbx
movq 0x10(%r15), %r15
jmp 0xb94e1
xorl %eax, %eax
jmp 0xb956a
cmpq 0x110(%r14), %rbx
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: free_vlist
static void free_vlist(s7_scheme *sc, s7_pointer lst)
    {
        if (is_pair(lst))
        {
            s7_pointer p, np;
            for (p = lst, np = cdr(lst); is_pair(p); p = np, np = unchecked_cdr(np))
                free_cell(sc, p);
        }
    }

// Assembly:
cmpb $0x1, (%rsi)
jne 0xb9853
movb $0x1, %al
cmpb $0x1, %al
jne 0xb9853
movq 0x10(%rsi), %rcx
andq $0x0, (%rsi)
movq 0x90(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x90(%rdi)
movq %rsi, (%rax)
movb (%rcx), %al
movq %rcx, %rsi
jmp 0xb982b
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: traverse_vector_data
static int32_t traverse_vector_data(s7_scheme *sc, s7_pointer vec, s7_int flat_ref, s7_int dimension, s7_int dimensions, s7_int *sizes, s7_pointer lst)
                {
                    /* we're filling vec, we're currently looking for element flat_ref,
                     *   we're at ref in dimension of dimensions, where sizes gives the bounds, and lst is our data
                     *   #3D(((1 2 3) (4 5 6)) ((7 8 9) (10 11 12)))
                     */
                    s7_int i;
                    s7_pointer x;

                    for (i = 0, x = lst; i < sizes[dimension]; i++, x = cdr(x))
                    {
                        if (!is_pair(x))
                            return(MULTIVECTOR_NOT_ENOUGH_ELEMENTS);

                        if (dimension == (dimensions - 1))
                            vector_setter(vec)(sc, vec, flat_ref++, car(x));
                        else
                        {
                            flat_ref = traverse_vector_data(sc, vec, flat_ref, dimension + 1, dimensions, sizes, car(x));
                            if (flat_ref < 0) return(flat_ref);
                        }
                    }
                    if (is_not_null(x))
                        return(MULTIVECTOR_TOO_MANY_ELEMENTS);
                    return(flat_ref);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %rcx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x60(%rsp), %rbp
movq %r8, 0x20(%rsp)
leaq -0x1(%r8), %r12
leaq 0x1(%rcx), %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
cmpq (%r13,%r15,8), %r14
jge 0xb9976
cmpb $0x1, (%rbp)
jne 0xb998a
cmpq %r15, %r12
jne 0xb9943
movq %r12, %rbx
leaq 0x1(%rdx), %r12
movq 0x8(%rbp), %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *0x28(%rsi)
movq %r12, %rdx
movq %rbx, %r12
jmp 0xb996d
movq 0x8(%rbp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq %r13, %r9
callq 0xb98d9
testl %eax, %eax
js 0xb998d
movl %eax, %edx
incq %r14
movq 0x10(%rbp), %rbp
jmp 0xb9911
movq 0x8(%rsp), %rax
cmpq 0x110(%rax), %rbp
pushq $-0x1
popq %rax
cmovel %edx, %eax
jmp 0xb998d
pushq $-0x2
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq