LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_count
static int32_t fx_count(s7_scheme *sc, s7_pointer x)
                {
                    int32_t count = 0;
                    s7_pointer p;
                    for (p = cdr(x); is_pair(p); p = cdr(p))
                        if (is_fxable(sc, car(p)))
                            count++;
                    return(count);
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rsi), %r14
xorl %ebp, %ebp
cmpb $0x1, (%r14)
jne 0xe06aa
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xcd0e8
movzbl %al, %eax
addl %eax, %ebp
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
je 0xe068f
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movb $0x1, %bl
cmpb $0x1, (%rsi)
jne 0xe0705
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xe06f7
testb $0x40, 0x2(%rsi)
jne 0xe06f7
movq %r12, %rdi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xd9bb5
cmpl $0x2, %eax
je 0xe0703
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
je 0xe06cb
jmp 0xe0705
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe0788
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 0xe0762
movq %r14, %rdi
callq 0xa550
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 0xe089b
movq %r15, 0x4d8(%r14)
movzbl (%rbx), %eax
cmpl $0x1, %eax
jne 0xe082f
movq 0x8(%rbx), %r12
movb (%r12), %al
cmpb $0x1, %al
jne 0xe07b0
movq 0x8(%r12), %r12
movb (%r12), %al
cmpb $0xa, %al
jne 0xe0826
testb $-0x80, 0x6(%r12)
jne 0xe0826
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 0xe0801
movq %r14, %rdi
callq 0xa550
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 0xe078f
cmpl $0xa, %eax
jne 0xe089b
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 0xe0876
movq %r14, %rdi
callq 0xa550
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_O3/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 0xe067a
cmpl %r15d, %eax
jne 0xe121d
movq 0x10(%r14), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0xd151a
movslq %r15d, %rax
leaq 0x65760(%rip), %rcx     # 0x146950
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_O3/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 -0x30085(%rip), %r9     # 0xb11e4
cmpq %r9, %rcx
je 0xe128f
movq 0x20(%rdx), %r8
addq $0x8, %rdx
cmpq %r9, %r8
je 0xe1295
leaq -0x27dc1(%rip), %r9     # 0xb94c1
cmpq %r9, %rcx
je 0xe129e
cmpq %r9, %r8
je 0xe12a4
xorl %eax, %eax
retq
movw $0x72, %cx
jmp 0xe12b6
movw $0x70, %cx
movq %rdx, %rax
jmp 0xe12b6
movw $0x72, %cx
jmp 0xe12ab
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_O3/BernardTatin[P]s7sh/s7.c
// Function: set_safe_closure_fp
static opt_t set_safe_closure_fp(s7_scheme *sc, s7_pointer func, s7_pointer expr, s7_pointer e, int32_t num_args, opcode_t op)
                {
                    s7_pointer p;
                    for (p = cdr(expr); is_pair(p); p = cdr(p))
                        set_c_call_checked(p, fx_choose(sc, p, e, (is_list(e)) ? pair_symbol_is_safe : let_symbol_is_safe));
                    set_opt3_arglen(expr, make_permanent_integer(num_args));
                    set_unsafe_optimize_op(expr, op);
                    set_opt1_lambda(expr, func);
                    return(OPT_F);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, 0x4(%rsp)
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq 0x10(%rdx), %rbx
cmpb $0x1, (%rbx)
jne 0xe15af
movq %rcx, %r12
movq %rdi, %r13
leaq -0x1440c(%rip), %r15    # 0xcd15c
leaq -0x3041a(%rip), %rbp    # 0xb1155
movb (%r12), %al
decb %al
cmpb $0x2, %al
movq %rbp, %rcx
cmovbq %r15, %rcx
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xaf535
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movq %rax, 0x20(%rbx)
movzwl 0x6(%rbx), %eax
andl $-0x5, %eax
leal (%rax,%rcx,4), %eax
movw %ax, 0x6(%rbx)
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0xe156f
movslq 0x4(%rsp), %rdi
callq 0xe05f3
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_O3/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 0xe1618
pushq %rax
callq 0xdb624
cmpb $0x20, (%rax)
jne 0xe161b
movq 0x10(%rax), %rax
cmpb $0x30, (%rax)
jb 0xe161b
movb 0x2(%rax), %al
andb $0x20, %al
shrb $0x5, %al
jmp 0xe161d
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: body_is_safe
static body_t body_is_safe(s7_scheme *sc, s7_pointer func, s7_pointer body, bool at_end)
                {
                    bool follow = false;
                    s7_pointer p, sp;
                    body_t result = VERY_SAFE_BODY;
                    /* fprintf(stderr, "%s: %s %s %d\n", __func__, DISPLAY(func), DISPLAY(body), at_end); */
                    for (p = body, sp = body; is_pair(p); p = cdr(p))
                    {
                        if (is_pair(car(p)))
                        {
                            result = min_body(result, form_is_safe(sc, func, car(p), (at_end) && (is_null(cdr(p)))));
                            if (result == UNSAFE_BODY) return_unsafe_body(sc);
                        }
                        if (p != body)
                        {
                            if (follow) {sp = cdr(sp); if (p == sp) return_unsafe_body(sc);}
                            follow = (!follow);
                        }
                    }
                    if (!is_null(p))
                        return_unsafe_body(sc);
                    return(result);
                }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x10(%rdx), %r12
cmpb $0x1, (%r12)
jne 0xe58af
movq %rcx, %r13
leaq -0x18704(%rip), %rbp    # 0xcd15c
leaq -0x34712(%rip), %r14    # 0xb1155
movb (%r13), %al
decb %al
cmpb $0x2, %al
movq %r14, %rcx
cmovbq %rbp, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xaf535
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movq %rax, 0x20(%r12)
movzwl 0x6(%r12), %eax
andl $-0x5, %eax
leal (%rax,%rcx,4), %eax
movw %ax, 0x6(%r12)
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xe5867
movslq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0xe05f3
movq 0x10(%rbx), %rcx
movq %rax, 0x28(%rcx)
movq 0x10(%rbx), %rax
andq $-0x40001, (%rax)       # imm = 0xFFFBFFFF
orq $0x800800, (%rbx)       # imm = 0x800800
movq 0x8(%rsp), %rax
movw %ax, 0x4(%rbx)
movq 0x10(%rsp), %r14
movq 0x8(%r14), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %rbx, %rcx
movl $0x1, %r8d
callq *0x48(%rax)
movq %rax, 0x18(%rbx)
movq 0x8(%r14), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %rbx, %rcx
movl $0x1, %r8d
callq *0x48(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x20(%rbx)
orb $0x4, 0x6(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bl
cmpb $0x1, (%rsi)
jne 0xe5979
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%r15), %rsi
cmpb $0xa, (%rsi)
jne 0xe596b
testb $-0x80, 0x6(%rsi)
jne 0xe596b
movq %r12, %rdi
movq %r14, %rdx
callq 0xe08a8
testb %al, %al
je 0xe5977
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
je 0xe594d
jmp 0xe5979
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe5a10
movq 0x8(%rsi), %rax
leaq -0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xe5a1f
leaq 0x60f47(%rip), %rcx     # 0x146950
movq -0x8(%rcx,%rax,8), %rax
jmp 0xe5a58
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba184
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe5a3e
movq %rbx, %rdi
callq 0xa550
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_O3/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 0xe5a9b
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xe5ab1
leaq 0x60ebc(%rip), %rcx     # 0x146950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xe5aea
movq 0x10(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb9ddd
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe5ad0
movq %rbx, %rdi
callq 0xa550
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_O3/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 0xe5bd4
movq 0x8(%rsi), %rax
leaq -0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xe5be3
leaq 0x60d83(%rip), %rcx     # 0x146950
movq -0x8(%rcx,%rax,8), %rax
jmp 0xe5c1c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba184
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe5c02
movq %rbx, %rdi
callq 0xa550
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_O3/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 0xe5c63
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xe5c79
leaq 0x60cf4(%rip), %rcx     # 0x146950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xe5cb2
movq 0x10(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb9ddd
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe5c98
movq %rbx, %rdi
callq 0xa550
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_O3/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 0x895ed
cmpb $0xb, (%rdx)
jne 0x895ed
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_O3/BernardTatin[P]s7sh/s7.c
// Function: fx_c_Wt_direct
static s7_pointer fx_c_Wt_direct(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer old_e, W;
                    old_e = sc->envir;
                    sc->envir = outlet(outlet(old_e));
                    W = lookup(sc, cadr(arg));
                    sc->envir = old_e;
                    return(((s7_p_pp_t)opt2_direct(cdr(arg)))(sc, W, slot_value(let_slots(sc->envir))));
                }

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rdx
movq 0x8(%rdx), %rdx
movq 0x18(%rax), %r9
movq 0x20(%rdx), %r8
cmpq %r8, %r9
je 0xe5e41
jle 0xe5e3c
movq 0x10(%rax), %rax
movq 0x18(%rax), %r9
cmpq %r9, %r8
jl 0xe5e2f
cmpq %r8, %r9
jne 0xe5e63
movq 0x18(%rdx), %r8
movq 0x10(%r8), %rax
movq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rdx
movq 0x20(%rdx), %r8
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdx
movq %rax, %rsi
jmpq *%r8
cmpb $0x1c, (%rax)
jne 0xe5e83
movq 0x8(%rax), %r8
testq %r8, %r8
je 0xe5e7d
cmpq %rdx, 0x8(%r8)
je 0xe5e45
movq 0x18(%r8), %r8
jmp 0xe5e6c
movq 0x10(%rax), %rax
jmp 0xe5e63
movq 0x10(%rdx), %r8
cmpb $0x20, (%r8)
je 0xe5e45
xorl %eax, %eax
jmp 0xe5e49
// File: /workspace/github_c_makefile_star2_O3/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
cmpq 0x110(%rdi), %rax
je 0xe5ef2
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
testb $0x4, 0x6(%rax)
je 0xe5f36
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
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)
cmpq 0x110(%rbx), %rax
jne 0xe5ea2
movq (%rbx), %rax
cmpb $0x1, (%rax)
jne 0xe5f17
movq 0x8(%rax), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rcx)
movq 0x8(%rax), %rcx
andq $-0x20000001, (%rcx)    # imm = 0xDFFFFFFF
movq 0x10(%rax), %rax
jmp 0xe5ef5
movq 0x50(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movups -0x20(%rax), %xmm0
movups %xmm0, (%rbx)
movq -0x10(%rax), %rax
movq %rax, 0x10(%rbx)
movb $0x1, %al
jmp 0xe5f72
movq (%rbx), %rcx
movq 0x50(%rbx), %rdx
movq %rcx, (%rdx)
movq 0x8(%rbx), %rcx
movq 0x50(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x10(%rbx), %rcx
movq 0x50(%rbx), %rdx
movq %rcx, 0x10(%rdx)
movq 0x50(%rbx), %rcx
movq $0x1e8, 0x18(%rcx)      # imm = 0x1E8
addq $0x20, 0x50(%rbx)
movq 0x8(%rax), %rax
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3fabd
movq %rax, %r15
movzbl (%rax), %eax
leaq 0x6564e(%rip), %rcx     # 0x14c330
cmpb $0x0, (%rax,%rcx)
jne 0xe6cf9
leaq 0x65681(%rip), %rcx     # 0x14c370
cmpb $0x1, (%rax,%rcx)
jne 0xe6dd4
cmpb $0x30, %al
jb 0xe6d31
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 0xe6d57
movq %rbx, %rdi
callq 0xa550
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_O3/BernardTatin[P]s7sh/s7.c
// Function: set_dilambda_opt
static void set_dilambda_opt(s7_scheme *sc, s7_pointer form, opcode_t opt, s7_pointer expr)
                {
                    s7_pointer func;
                    func = lookup_checked(sc, car(expr));
                    if ((is_closure(func)) &&
                            (is_closure(closure_setter(func))) &&
                            (is_safe_closure(closure_setter(func))))
                    {
                        s7_pointer setter;
                        setter = closure_setter(func);
                        pair_set_syntax_op(form, opt);
                        if ((!(is_let(closure_let(setter)))) ||
                                (!(is_funclet(closure_let(setter)))))
                            make_funclet(sc, setter, car(expr), closure_let(setter));
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rcx), %rsi
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rsi), %rcx
cmpq %rcx, %rdx
je 0xe6e23
jle 0xe6e1e
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdx
cmpq %rdx, %rcx
jl 0xe6e11
cmpq %rcx, %rdx
jne 0xe6e58
movq 0x18(%rsi), %rcx
movq 0x10(%rcx), %rax
testq %rax, %rax
jne 0xe6e38
movq %r14, %rdi
callq 0x9c492
cmpb $0x28, (%rax)
jne 0xe6e4c
movq 0x20(%rax), %rsi
cmpb $0x28, (%rsi)
jne 0xe6e4c
testb $0x10, 0x1(%rsi)
jne 0xe6e83
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x1c, (%rax)
jne 0xe6e78
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xe6e72
cmpq %rsi, 0x8(%rcx)
je 0xe6e27
movq 0x18(%rcx), %rcx
jmp 0xe6e61
movq 0x10(%rax), %rax
jmp 0xe6e58
movq 0x10(%rsi), %rcx
cmpb $0x20, (%rcx)
je 0xe6e27
jmp 0xe6e30
movw %r12w, 0x4(%r15)
movw $0x201, (%r15)          # imm = 0x201
movq 0x18(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0xe6e9d
testb $0x20, 0x3(%rcx)
jne 0xe6e4c
movq 0x8(%rbx), %rdx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe5f74
// File: /workspace/github_c_makefile_star2_O3/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 0xe71c4
cmpb $0x1, 0x24c(%rbx)
jne 0xe71c4
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x8a63
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x9058e
cmpb %r8b, %al
jne 0xe71cf
btl $0x18, %eax
jb 0xe7200
movq 0x8(%r14), %rsi
movq 0x5f77e(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %rax
movzbl %r8b, %edi
leaq 0x63874(%rip), %r8      # 0x14aa60
movq (%r8,%rdi,8), %r9
movq %rbx, %rdi
movq %rax, %r8
popq %rbx
popq %r14
popq %r15
jmp 0xa4e4
movq 0x63761(%rip), %rax     # 0x14a968
movq 0x6e8(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %r14, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e8(%rbx), %rdx
movq 0xea8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/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 0xcd0e8
testb %al, %al
je 0xe8262
movq 0x8(%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x700(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%r14), %rdx
movb (%rdx), %al
decb %al
cmpb $0x2, %al
leaq -0x1b0c7(%rip), %rax    # 0xcd15c
leaq -0x370d5(%rip), %rcx    # 0xb1155
cmovbq %rax, %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xaf535
movq %rax, 0x20(%r15)
orb $0x4, 0x6(%r15)
movq (%r14), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdi
movq 0x8(%rcx), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0xcd182
movw $0x25e, %ax             # imm = 0x25E
jmp 0xe826d
movw $0x25c, %ax             # imm = 0x25C
cmpb $0x1, (%r12)
jne 0xe8276
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_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x28(%rdi)
movq 0x10(%rax), %rdi
movq %rdi, (%rbx)
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rdx
movq 0x8(%rdx), %rsi
movq 0x18(%rcx), %rdx
movq 0x20(%rsi), %r9
cmpq %r9, %rdx
je 0xe82cc
movq %rcx, %r8
movq %rdx, %r10
jle 0xe82c7
movq %rcx, %r8
movq 0x10(%r8), %r8
movq 0x18(%r8), %r10
cmpq %r10, %r9
jl 0xe82ba
cmpq %r9, %r10
jne 0xe832a
movq 0x18(%rsi), %r9
movq 0x10(%r9), %rsi
movq 0x10(%rdi), %rdi
movq 0x28(%rdi), %rdi
movq 0x20(%rdi), %r8
cmpq %r8, %rdx
je 0xe82f9
jle 0xe82f4
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdx
cmpq %rdx, %r8
jl 0xe82e7
cmpq %r8, %rdx
jne 0xe834b
movq 0x18(%rdi), %rdx
movq 0x10(%rdx), %rcx
movq 0x578(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x570(%rbx), %rcx
movq %rsi, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, 0x20(%rbx)
popq %rbx
retq
cmpb $0x1c, (%r8)
jne 0xe836b
movq 0x8(%r8), %r9
testq %r9, %r9
je 0xe8345
cmpq %rsi, 0x8(%r9)
je 0xe82d0
movq 0x18(%r9), %r9
jmp 0xe8334
movq 0x10(%r8), %r8
jmp 0xe832a
cmpb $0x1c, (%rcx)
jne 0xe8380
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xe8365
cmpq %rdi, 0x8(%rdx)
je 0xe82fd
movq 0x18(%rdx), %rdx
jmp 0xe8354
movq 0x10(%rcx), %rcx
jmp 0xe834b
movq 0x10(%rsi), %r9
cmpb $0x20, (%r9)
je 0xe82d0
xorl %esi, %esi
jmp 0xe82d4
movq 0x10(%rdi), %rdx
cmpb $0x20, (%rdx)
je 0xe82fd
xorl %ecx, %ecx
jmp 0xe8301
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rcx, 0x28(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, (%rdi)
movq 0x20(%rdx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rsi
movq 0x18(%rax), %rcx
movq 0x20(%rsi), %r8
cmpq %r8, %rcx
je 0xe83e0
movq %rax, %rdi
movq %rcx, %r9
jle 0xe83db
movq %rax, %rdi
movq 0x10(%rdi), %rdi
movq 0x18(%rdi), %r9
cmpq %r9, %r8
jl 0xe83ce
cmpq %r8, %r9
jne 0xe8427
movq 0x18(%rsi), %r8
movq 0x10(%r8), %rsi
movq 0x10(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x20(%rdx), %rdi
cmpq %rdi, %rcx
je 0xe840d
jle 0xe8408
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
cmpq %rcx, %rdi
jl 0xe83fb
cmpq %rdi, %rcx
jne 0xe844b
movq 0x18(%rdx), %rcx
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0xe846b
movq %rbx, %rdi
callq 0x39db6
jmp 0xe84ae
cmpb $0x1c, (%rdi)
jne 0xe84b4
movq 0x8(%rdi), %r8
testq %r8, %r8
je 0xe8445
cmpq %rsi, 0x8(%r8)
je 0xe83e4
movq 0x18(%r8), %r8
jmp 0xe8434
movq 0x10(%rdi), %rdi
jmp 0xe8427
cmpb $0x1c, (%rax)
jne 0xe84c9
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xe8465
cmpq %rdx, 0x8(%rcx)
je 0xe8411
movq 0x18(%rcx), %rcx
jmp 0xe8454
movq 0x10(%rax), %rax
jmp 0xe844b
cmpq 0x110(%rbx), %rdx
je 0xe84a7
movq 0x708(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x710(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x708(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x887db
jmp 0xe84ae
movq 0x120(%rbx), %rax
movq %rax, 0x20(%rbx)
popq %rbx
retq
movq 0x10(%rsi), %r8
cmpb $0x20, (%r8)
je 0xe83e4
xorl %esi, %esi
jmp 0xe83e8
movq 0x10(%rdx), %rcx
cmpb $0x20, (%rcx)
je 0xe8411
xorl %edx, %edx
jmp 0xe8415
// File: /workspace/github_c_makefile_star2_O3/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
cmpb $0x1, (%rdi)
jne 0xe88d2
movl %esi, %ebp
movq %rdi, %rbx
testb $0x4, 0x2(%rbx)
je 0xe88b9
movl 0x2c(%rbx), %eax
testl %eax, %eax
je 0xe88b9
testl %ebp, %ebp
je 0xe88b7
cmpl %ebp, %eax
jae 0xe88b9
jmp 0xe88d9
movl %eax, %ebp
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq 0xe8893
testq %rax, %rax
jne 0xe88d6
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0xe88a0
xorl %ebx, %ebx
jmp 0xe88d9
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe892d
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 0xe8963
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 0xe896d
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_O3/BernardTatin[P]s7sh/s7.c
// Function: reverse_in_place
static s7_pointer reverse_in_place(s7_scheme *sc, s7_pointer term, s7_pointer list)
                {
                    s7_pointer p, result;

                    if (is_null(list)) return(term);
                    p = list;
                    result = term;
                    while (true)
                    {
                        s7_pointer q;
                        q = cdr(p);
                        if (is_null(q))
                        {
                            set_cdr(p, result);
                            return(p);
                        }
                        if ((is_pair(q)) && (!is_immutable_pair(q)))
                        {
                            set_cdr(p, result);
                            result = p;
                            p = q;
                        }
                        else return(sc->nil); /* improper or immutable */
                    }
                    return(result);
                }

// Assembly:
movq 0x110(%rdi), %rax
cmpq %rdx, %rax
je 0xe89d3
movq 0x10(%rdx), %rcx
cmpq %rax, %rcx
je 0xe89dd
cmpb $0x1, (%rcx)
jne 0xe89d2
leaq 0x10(%rdx), %r8
testb $0x1, 0x3(%rcx)
jne 0xe89d2
movq %rdx, %r9
movq %rsi, (%r8)
movq 0x10(%rcx), %r10
movq 0x110(%rdi), %rax
cmpq %rax, %r10
je 0xe89d7
cmpb $0x1, (%r10)
leaq 0x10(%rcx), %r8
movq %rcx, %rdx
movq %r9, %rsi
movq %r10, %rcx
je 0xe89a3
retq
movq %rsi, %rax
retq
movq %rcx, %rdx
movq %r9, %rsi
movq %rsi, 0x10(%rdx)
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0xe8f89
leaq 0x110(%rbx), %r12
movq %r14, %r15
movq 0x8(%r15), %rsi
cmpb $0x1, (%rsi)
jne 0xe8f29
movq %rbx, %rdi
callq 0xe8ef1
testb %al, %al
jne 0xe8f3e
jmp 0xe8f9f
cmpq 0x17b8(%rbx), %rsi
je 0xe8f9f
cmpq (%r12), %rsi
jne 0xe8f3e
cmpq %rsi, 0x10(%r15)
je 0xe8f9f
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0xe8f96
cmpq %r14, %r15
je 0xe8f9f
movq 0x8(%r15), %rsi
cmpb $0x1, (%rsi)
jne 0xe8f64
movq %rbx, %rdi
callq 0xe8ef1
testb %al, %al
jne 0xe8f79
jmp 0xe8f9f
cmpq 0x17b8(%rbx), %rsi
je 0xe8f9f
cmpq (%r12), %rsi
jne 0xe8f79
cmpq %rsi, 0x10(%r15)
je 0xe8f9f
movq 0x10(%r15), %r15
movq 0x10(%r14), %r14
cmpb $0x1, (%r15)
je 0xe8f12
jmp 0xe8f8c
movq %r14, %r15
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %r12
cmpq (%r12), %r15
sete %al
jmp 0xe8fa1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq