LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xd5a05
testb %al, %al
je 0xf1026
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 -0x1b569(%rip), %rax    # 0xd5a7e
leaq -0x38e66(%rip), %rcx    # 0xb8188
cmovbq %rax, %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xb69b9
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 0xd5a9e
movw $0x25e, %ax             # imm = 0x25E
jmp 0xf1031
movw $0x25c, %ax             # imm = 0x25C
cmpb $0x1, (%r12)
jne 0xf103a
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_O1/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), %r8
movq 0x18(%rcx), %rsi
movq 0x20(%r8), %rdx
cmpq %rdx, %rsi
je 0xf1090
movq %rcx, %r9
movq %rsi, %r10
jle 0xf108b
movq %rcx, %r9
movq 0x10(%r9), %r9
movq 0x18(%r9), %r10
cmpq %r10, %rdx
jl 0xf107e
cmpq %rdx, %r10
jne 0xf10ee
movq 0x18(%r8), %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rdi), %rdi
movq 0x28(%rdi), %rdi
movq 0x20(%rdi), %r8
cmpq %r8, %rsi
je 0xf10bd
jle 0xf10b8
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %r8
jl 0xf10ab
cmpq %r8, %rsi
jne 0xf1134
movq 0x18(%rdi), %rcx
movq 0x10(%rcx), %rsi
movq 0x578(%rbx), %rcx
movq %rsi, 0x8(%rcx)
movq 0x570(%rbx), %rcx
movq %rdx, 0x8(%rcx)
movq 0x570(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, 0x20(%rbx)
popq %rbx
retq
cmpb $0x1c, (%r9)
jne 0xf1120
movq 0x8(%r9), %r11
testq %r11, %r11
sete %r10b
je 0xf1111
cmpq %r8, 0x8(%r11)
je 0xf110d
movq 0x18(%r11), %r11
jmp 0xf10f8
movq 0x10(%r11), %rdx
testb %r10b, %r10b
je 0xf1098
movq 0x10(%r9), %r9
cmpb $0x1c, (%r9)
je 0xf10f4
movq 0x10(%r8), %rdx
cmpb $0x20, (%rdx)
je 0xf1094
xorl %edx, %edx
jmp 0xf1098
cmpb $0x1c, (%rcx)
jne 0xf1168
movq 0x8(%rcx), %r9
testq %r9, %r9
sete %r8b
je 0xf1156
cmpq %rdi, 0x8(%r9)
je 0xf1152
movq 0x18(%r9), %r9
jmp 0xf113d
movq 0x10(%r9), %rsi
testb %r8b, %r8b
je 0xf10c5
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xf1139
movq 0x10(%rdi), %rcx
cmpb $0x20, (%rcx)
je 0xf10c1
xorl %esi, %esi
jmp 0xf10c5
// File: /workspace/github_c_makefile_star2_O1/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), %rdi
movq 0x18(%rax), %rcx
movq 0x20(%rdi), %rsi
cmpq %rsi, %rcx
je 0xf11cc
movq %rax, %r8
movq %rcx, %r9
jle 0xf11c3
movq %rax, %r8
movq 0x10(%r8), %r8
movq 0x18(%r8), %r9
cmpq %r9, %rsi
jl 0xf11b6
cmpq %rsi, %r9
jne 0xf125a
movq 0x18(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq 0x10(%rdx), %rdx
movq 0x28(%rdx), %rdi
movq 0x20(%rdi), %rdx
cmpq %rdx, %rcx
je 0xf11fd
jle 0xf11f4
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
cmpq %rcx, %rdx
jl 0xf11e7
cmpq %rdx, %rcx
jne 0xf12a4
movq 0x18(%rdi), %rax
movq 0x10(%rax), %rdx
cmpb $0x1, (%rdx)
jne 0xf1217
movq %rbx, %rdi
callq 0x3c342
jmp 0xf12f1
cmpq 0x110(%rbx), %rdx
je 0xf12ea
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 0x8eed4
jmp 0xf12f1
cmpb $0x1c, (%r8)
jne 0xf1290
movq 0x8(%r8), %r10
testq %r10, %r10
sete %r9b
je 0xf127d
cmpq %rdi, 0x8(%r10)
je 0xf1279
movq 0x18(%r10), %r10
jmp 0xf1264
movq 0x10(%r10), %rsi
testb %r9b, %r9b
je 0xf11d4
movq 0x10(%r8), %r8
cmpb $0x1c, (%r8)
je 0xf1260
movq 0x10(%rdi), %rsi
cmpb $0x20, (%rsi)
je 0xf11d0
xorl %esi, %esi
jmp 0xf11d4
cmpb $0x1c, (%rax)
jne 0xf12d6
movq 0x8(%rax), %r8
testq %r8, %r8
sete %cl
je 0xf12c5
cmpq %rdi, 0x8(%r8)
je 0xf12c1
movq 0x18(%r8), %r8
jmp 0xf12ad
movq 0x10(%r8), %rdx
testb %cl, %cl
je 0xf1205
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
je 0xf12a9
movq 0x10(%rdi), %rax
cmpb $0x20, (%rax)
je 0xf1201
xorl %edx, %edx
jmp 0xf1205
movq 0x120(%rbx), %rax
movq %rax, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rsi, %rbx
movq 0x250(%rdi), %rax
incq %rax
movq %rax, 0x250(%rdi)
movq %rax, 0x18(%rsi)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
movq %rsi, 0x8(%rdi)
cmpb $0x1, (%rdx)
jne 0xf1385
movq %rdx, %r14
movq %rdi, %r15
leaq 0x8(%rbx), %r12
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
cmpb $0x1, (%r14)
je 0xf1332
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: 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
movq %rdi, %rbx
cmpb $0x1, (%rbx)
jne 0xf1712
testb $0x4, 0x2(%rbx)
jne 0xf16e5
movl %esi, %ebp
jmp 0xf16fa
movl 0x2c(%rbx), %eax
testl %esi, %esi
movl %esi, %ebp
cmovel %eax, %ebp
testl %eax, %eax
cmovel %esi, %ebp
je 0xf16fa
cmpl %esi, %eax
jb 0xf1719
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq 0xf16d0
testq %rax, %rax
jne 0xf1716
movq 0x10(%rbx), %rbx
movl %ebp, %esi
jmp 0xf16d6
xorl %ebx, %ebx
jmp 0xf1719
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
movq 0x48(%rdi), %rax
movq 0x10(%rcx), %rdx
movq 0x50(%rdi), %rsi
movq %rsi, %r8
subq %rax, %r8
movq -0x8(%rdx,%r8), %rdx
cmpq $0x1d3, %rdx            # imm = 0x1D3
jne 0xf176a
leaq -0x20(%rsi), %rdx
movq %rdx, 0x50(%rdi)
movups -0x20(%rsi), %xmm0
movups -0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x10(%rcx), %rsi
subq %rax, %rdx
movq -0x8(%rsi,%rdx), %rdx
movq %rdx, %rsi
andq $-0x4, %rsi
cmpq $0x1d8, %rsi            # imm = 0x1D8
jne 0xf17a1
movq 0x50(%rdi), %rdx
leaq -0x20(%rdx), %rsi
movq %rsi, 0x50(%rdi)
movups -0x20(%rdx), %xmm0
movups -0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x10(%rcx), %rcx
subq %rax, %rsi
movq -0x8(%rcx,%rsi), %rdx
cmpq $0x1d4, %rdx            # imm = 0x1D4
je 0xf17ab
retq
movq 0x50(%rdi), %rax
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_O1/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, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0xf1d06
movq %r14, %r15
movq 0x8(%r15), %rsi
cmpb $0x1, (%rsi)
jne 0xf1c96
movq %rbx, %rdi
callq 0xf1c68
testb %al, %al
jne 0xf1cb1
jmp 0xf1d15
cmpq 0x17b8(%rbx), %rsi
je 0xf1d15
movq 0x110(%rbx), %rax
cmpq %rax, %rsi
jne 0xf1cb1
cmpq %rax, 0x10(%r15)
je 0xf1d15
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0xf1d09
cmpq %r14, %r15
je 0xf1d15
movq 0x8(%r15), %rsi
cmpb $0x1, (%rsi)
jne 0xf1cd7
movq %rbx, %rdi
callq 0xf1c68
testb %al, %al
jne 0xf1cf2
jmp 0xf1d15
cmpq 0x17b8(%rbx), %rsi
je 0xf1d15
movq 0x110(%rbx), %rax
cmpq %rax, %rsi
jne 0xf1cf2
cmpq %rax, 0x10(%r15)
je 0xf1d15
movq 0x10(%r15), %r15
movq 0x10(%r14), %r14
cmpb $0x1, (%r15)
je 0xf1c7f
jmp 0xf1d09
movq %r14, %r15
cmpq 0x110(%rbx), %r15
sete %al
jmp 0xf1d17
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x60(%rsp), %rbp
cmpq $0x0, (%r9,%rcx,8)
jle 0xf2283
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
leaq -0x1(%r8), %r13
leaq 0x1(%rcx), %rax
movq %rax, 0x18(%rsp)
xorl %ebx, %ebx
movq %rcx, 0x20(%rsp)
cmpb $0x1, (%rbp)
jne 0xf2299
cmpq %r12, %r13
jne 0xf224d
movq %r14, %r12
movq %r13, %r14
movq %r15, %r13
leaq 0x1(%rdx), %r15
movq 0x8(%rbp), %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *0x28(%rsi)
movq %r15, %rdx
movq %r13, %r15
movq %r14, %r13
movq %r12, %r14
movq 0x20(%rsp), %r12
jmp 0xf2276
movq 0x8(%rbp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq %r15, %r8
movq %r14, %r9
callq 0xf21c8
testl %eax, %eax
js 0xf229e
movslq %eax, %rdx
incq %rbx
movq 0x10(%rbp), %rbp
cmpq (%r14,%r12,8), %rbx
jl 0xf220d
movq 0x8(%rsp), %rax
cmpq 0x110(%rax), %rbp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %edx, %eax
jmp 0xf229e
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_let_iterate
static s7_pointer s7_let_iterate(s7_scheme *sc, s7_pointer iterator)
                {
                    s7_pointer symbol, value, osw;

                    iterator_position(iterator)++;
                    if (iterator_position(iterator) >= SL_NUM_FIELDS)
                        return(iterator_quit(iterator));

                    symbol = make_symbol(sc, s7_let_field_names[iterator_position(iterator)]);
                    osw = sc->w;  /* protect against s7_let_field list making */
                    value = s7_let_field(sc, symbol);
                    sc->w = osw;

                    if (iterator_let_cons(iterator))
                    {
                        s7_pointer p;
                        p = iterator_let_cons(iterator);
                        set_car(p, symbol);
                        set_cdr(p, value);
                        return(p);
                    }
                    return(cons(sc, symbol, value));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq 0x18(%rsi), %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x18(%rsi)
cmpq $0x2b, %rcx
jl 0xf22e4
leaq -0xb86c3(%rip), %rax    # 0x39c0f
movq %rax, 0x28(%r15)
andb $0x7f, 0x3(%r15)
movq 0x5c47e(%rip), %rax     # 0x14e760
jmp 0xf235f
movq %rdi, %rbx
leaq 0x205f2(%rip), %rcx     # 0x1128e0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
callq 0xaa9f
movq %rax, %r14
movq 0x4d8(%rbx), %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf2369
movq %rax, %r12
movq %r13, 0x4d8(%rbx)
movq 0x10(%r15), %rax
testq %rax, %rax
jne 0xf2357
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xf233a
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %r12, 0x10(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mark_closure
static void mark_closure(s7_pointer p)
    {
        set_mark(p);
        gc_mark(closure_args(p));
        gc_mark(closure_body(p));
        mark_let(closure_let(p));
        gc_mark(closure_setter_or_map_list(p));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x8(%rdi), %rdi
cmpq $0x0, (%rdi)
leaq 0x59fc4(%rip), %r14     # 0x14e770
js 0xf47b5
movzbl (%rdi), %eax
callq *(%r14,%rax,8)
movq 0x10(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0xf47c6
movzbl (%rdi), %eax
callq *(%r14,%rax,8)
movq 0x18(%rbx), %rdi
callq 0x94d53
movq 0x20(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0xf47e9
movzbl (%rdi), %eax
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mark_continuation
static void mark_continuation(s7_pointer p)
    {
        set_mark(p);
        if (!is_marked(continuation_stack(p))) /* can these be cyclic? */
            mark_stack_1(continuation_stack(p), continuation_stack_top(p));
        gc_mark(continuation_op_stack(p));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x10(%rdi), %rdi
cmpq $0x0, (%rdi)
js 0xf4814
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x3, %rsi
callq 0x94ed3
movq 0x18(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0xf482c
movzbl (%rdi), %eax
leaq 0x59f48(%rip), %rcx     # 0x14e770
popq %rbx
jmpq *(%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mark_dynamic_wind
static void mark_dynamic_wind(s7_pointer p)
    {
        set_mark(p);
        gc_mark(dynamic_wind_in(p));
        gc_mark(dynamic_wind_out(p));
        gc_mark(dynamic_wind_body(p));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x8(%rdi), %rdi
cmpq $0x0, (%rdi)
leaq 0x59eb4(%rip), %rcx     # 0x14e770
js 0xf48ca
movzbl (%rdi), %eax
movq %rcx, %r14
callq *(%rcx,%rax,8)
movq %r14, %rcx
movq 0x10(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0xf48e0
movzbl (%rdi), %eax
movq %rcx, %r14
callq *(%rcx,%rax,8)
movq %r14, %rcx
movq 0x18(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0xf48f7
movzbl (%rdi), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mark_iterator
static void mark_iterator(s7_pointer p)
    {
        set_mark(p);
        gc_mark(iterator_sequence(p));
        if (is_mark_seq(p))
            gc_mark(iterator_current(p));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x8(%rdi), %rdi
cmpq $0x0, (%rdi)
js 0xf4a51
movzbl (%rdi), %eax
leaq 0x59d22(%rip), %rcx     # 0x14e770
callq *(%rcx,%rax,8)
testb $0x4, 0x3(%rbx)
je 0xf4a6f
movq 0x10(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0xf4a6f
movzbl (%rdi), %eax
leaq 0x59d05(%rip), %rcx     # 0x14e770
popq %rbx
jmpq *(%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mark_counter
static void mark_counter(s7_pointer p)
    {
        set_mark(p);
        gc_mark(counter_result(p));
        gc_mark(counter_list(p));
        gc_mark(counter_let(p));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x8(%rdi), %rdi
cmpq $0x0, (%rdi)
leaq 0x59cdc(%rip), %rcx     # 0x14e770
js 0xf4aa2
movzbl (%rdi), %eax
movq %rcx, %r14
callq *(%rcx,%rax,8)
movq %r14, %rcx
movq 0x10(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0xf4ab8
movzbl (%rdi), %eax
movq %rcx, %r14
callq *(%rcx,%rax,8)
movq %r14, %rcx
movq 0x18(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0xf4acf
movzbl (%rdi), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: undefined_to_port
static void undefined_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        if ((obj != sc->undefined) &&
                (use_write == P_READABLE))
        {
            port_write_string(port)(sc, "(with-input-from-string \"",25, port);
            port_write_string(port)(sc, unknown_name(obj), unique_name_length(obj), port);
            port_write_string(port)(sc, "\" read)", 7, port);
        }
        else port_write_string(port)(sc, unknown_name(obj), unique_name_length(obj), port);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x2, %ecx
jne 0xfa57d
cmpq %r15, 0x128(%r14)
je 0xfa57d
leaq 0x29230(%rip), %rsi     # 0x12376d
movl $0x19, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq *%rax
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq *0x10(%rax)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
leaq 0x29211(%rip), %rsi     # 0x123787
movl $0x7, %edx
jmp 0xfa585
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: baffle_to_port
static void baffle_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        int32_t nlen;          /* (with-baffle (display (curlet)) (newline)) */
        char buf[64];
        nlen = catstrs_direct(buf, "#<baffle: ", pos_int_to_str_direct(sc, baffle_key(obj)), ">", NULL);
        port_write_string(port)(sc, buf, nlen, port);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
leaq 0xb6f(%rdi), %r8
movb $0x0, 0xb6f(%rdi)
leaq 0x24917(%rip), %rcx     # 0x11f430
movabsq $0x6666666666666667, %rdi # imm = 0x6666666666666667
movq %rsi, %rax
imulq %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rsi, %r9
subq %rax, %r9
movb (%rcx,%r9), %al
movb %al, -0x1(%r8)
decq %r8
addq $0x9, %rsi
cmpq $0x12, %rsi
movq %rdx, %rsi
ja 0xfab23
leaq 0x28e0a(%rip), %rsi     # 0x12396e
leaq 0x28ec6(%rip), %rcx     # 0x123a31
movq %rsp, %r15
movq %r15, %rdi
movq %r8, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xd1cb
movq 0x8(%rbx), %rcx
movq 0x48(%rcx), %r8
movslq %eax, %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq *0x10(%r8)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: number_to_port
static void number_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        if (has_print_name(obj))
            port_write_string(port)(sc, print_name(obj), print_name_length(obj), port);
        else
        {
            s7_int nlen;
            char *str;
            nlen = 0;
            str = number_to_string_base_10(sc, obj, 0, sc->float_format_precision, 'g', &nlen, use_write); /* was 14 */
            if ((nlen < PRINT_NAME_SIZE) &&
                    (str[0] != 'n') && (str[0] != 'i') &&
                    ((!(is_t_complex(obj))) ||
                     ((!is_NaN(imag_part(obj))) && (!is_inf(imag_part(obj))))))
                set_print_name(obj, str, nlen);
            port_write_string(port)(sc, str, nlen, port);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testb $0x8, 0x3(%rsi)
jne 0xfadf0
movq %rsp, %r13
movq $0x0, (%r13)
movslq 0x468(%r14), %rcx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl $0x67, %r8d
movq %r13, %r9
callq 0x95820
movq %rax, %r12
movq (%r13), %r13
cmpq $0x15, %r13
jg 0xfadd9
movzbl (%r12), %eax
cmpl $0x69, %eax
je 0xfadd9
cmpl $0x6e, %eax
jne 0xfae1e
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
jmp 0xfae0b
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movzbl 0x18(%r15), %edx
addq $0x19, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
cmpb $0xe, (%r15)
jne 0xfae4e
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq 0x10(%r15), %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
setl %al
cmpl $0x14, %r13d
jg 0xfadd9
testb %al, %al
jne 0xfae54
jmp 0xfadd9
cmpl $0x14, %r13d
jg 0xfadd9
movq (%r15), %rax
btl $0x1a, %eax
jb 0xfadd9
orq $0x8000000, %rax        # imm = 0x8000000
movq %rax, (%r15)
movb %r13b, 0x18(%r15)
leaq 0x19(%r15), %rdi
movslq %r13d, %rbp
movq %r12, %rsi
movq %rbp, %rdx
callq 0x93e0
movb $0x0, 0x19(%r15,%rbp)
jmp 0xfadd9
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: c_function_to_port
static void c_function_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        if (use_write == P_READABLE)
        {
            s7_pointer sym;
            sym = make_symbol(sc, c_function_name(obj));
            if ((is_slot(initial_slot(sym))) && (!is_global(sym)))
            {
                port_write_string(port)(sc, "#_", 2, port);
                port_write_string(port)(sc, c_function_name(obj), c_function_name_length(obj), port);
                return;
            }
        }
        if (c_function_name_length(obj) > 0)
            port_write_string(port)(sc, c_function_name(obj), c_function_name_length(obj), port);
        else port_write_string(port)(sc, "#<unnamed-c-function>", 21, port);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x2, %ecx
jne 0xfbc83
movq 0x8(%r15), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xaa9f
movq 0x8(%rax), %rcx
movq 0x20(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpb $0x20, (%rcx)
jne 0xfbc83
testb $0x1, 0x2(%rax)
jne 0xfbc83
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
leaq 0x27ded(%rip), %rsi     # 0x123a49
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq *0x10(%rax)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%r15), %rcx
movq (%rcx), %rsi
movslq 0x8(%rcx), %rdx
jmp 0xfbcad
movq 0x8(%r15), %rcx
movslq 0x8(%rcx), %rdx
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
testq %rdx, %rdx
jle 0xfbca1
movq (%rcx), %rsi
jmp 0xfbcad
leaq 0x27da4(%rip), %rsi     # 0x123a4c
movl $0x15, %edx
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: multivector_indices_to_string
static char *multivector_indices_to_string(s7_scheme *sc, s7_int index, s7_pointer vect, char *str, int32_t cur_dim)
    {
        s7_int size, ind;

        size = vector_dimension(vect, cur_dim);
        ind = index % size;
        if (cur_dim > 0)
            multivector_indices_to_string(sc, (index - ind) / size, vect, str, cur_dim - 1);
        catstrs(str, 128, " ", pos_int_to_str_direct(sc, ind), NULL);
        return(str);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdx), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movslq %r8d, %rdx
movq (%rax,%rdx,8), %r12
testl %edx, %edx
jle 0xfd160
movq %r15, %rax
cqto
idivq %r12
decl %r8d
movq %r14, %rdi
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0xfd11a
movq %r15, %rax
cqto
idivq %r12
movq %rdx, %rcx
movb $0x0, 0xb6f(%r14)
addq $0xb6f, %r14            # imm = 0xB6F
leaq 0x222af(%rip), %rsi     # 0x11f430
movabsq $0x6666666666666667, %rdi # imm = 0x6666666666666667
movq %rcx, %rax
imulq %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r8
subq %rax, %r8
movb (%rsi,%r8), %al
movb %al, -0x1(%r14)
decq %r14
addq $0x9, %rcx
cmpq $0x12, %rcx
movq %rdx, %rcx
ja 0xfd18b
leaq 0x262da(%rip), %rdx     # 0x1234a6
movl $0x80, %esi
movq %rbx, %rdi
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xa4d7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: slot_setters_to_port
static void slot_setters_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, shared_info *ci)
    {
        s7_pointer slot;
        for (slot = let_slots(obj); tis_slot(slot); slot = next_slot(slot))
            if (slot_has_setter(slot))
            {
                port_write_string(port)(sc, "(set! (setter '", 15, port);
                symbol_to_port(sc, slot_symbol(slot), port, P_DISPLAY, ci);
                port_write_string(port)(sc, ") ", 2, port);
                object_to_port_with_circle_check(sc, slot_setter(slot), port, P_READABLE, ci);
                port_write_character(port)(sc, ')', port);
            }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rbp
testq %rbp, %rbp
je 0xfdf97
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x25891(%rip), %r12     # 0x12375d
leaq 0x257d2(%rip), %r13     # 0x1236a5
testb $0x4, 0x2(%rbp)
je 0xfdf8a
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movl $0xf, %edx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq *0x10(%rax)
movq 0x8(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xfae8b
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movl $0x2, %edx
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq *0x10(%rax)
movq 0x28(%rbp), %rsi
testq %rbx, %rbx
je 0xfdf58
movzbl (%rsi), %eax
leaq 0x5c40d(%rip), %rcx     # 0x15a340
cmpb $0x1, (%rax,%rcx)
jne 0xfdf58
cmpb $0x15, %al
jne 0xfdf43
testb $0x1, 0x7(%rsi)
jne 0xfdf58
movq %r15, %rdi
movq %r14, %rdx
movl $0x2, %ecx
movq %rbx, %r8
callq 0x9c033
jmp 0xfdf74
movzbl (%rsi), %eax
movq %r15, %rdi
movq %r14, %rdx
movl $0x2, %ecx
movq %rbx, %r8
leaq 0x5c410(%rip), %r9      # 0x15a380
callq *(%r9,%rax,8)
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %r15, %rdi
movl $0x29, %esi
movq %r14, %rdx
callq *0x8(%rax)
movq 0x18(%rbp), %rbp
testq %rbp, %rbp
jne 0xfded3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: slot_list_to_port
static void slot_list_to_port(s7_scheme *sc, s7_pointer slot, s7_pointer port, shared_info *ci, bool bindings)
    {
        if (tis_slot(slot))
        {
            slot_list_to_port(sc, next_slot(slot), port, ci, bindings);
            if (bindings)
            {
                if (tis_slot(next_slot(slot)))
                    port_write_string(port)(sc, " (", 2, port);
                else port_write_character(port)(sc, '(', port);
            }
            else port_write_character(port)(sc, ' ', port);
            symbol_to_port(sc, slot_symbol(slot), port, (bindings) ? P_DISPLAY : P_KEY, ci);  /* (object->string (inlet (symbol "(\")") 1) :readable) */
            port_write_character(port)(sc, ' ', port);
            object_to_port_with_circle_check(sc, slot_value(slot), port, P_READABLE, ci);
            if (bindings) port_write_character(port)(sc, ')', port);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xfe0d9
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rsi), %rsi
movzbl %bpl, %r13d
movl %r13d, %r8d
callq 0xfdfa6
testb %r13b, %r13b
je 0xfe005
cmpq $0x0, 0x18(%r12)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
je 0xfe022
leaq 0x2553d(%rip), %rsi     # 0x123532
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq *0x10(%rax)
jmp 0xfe030
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq *0x8(%rax)
movl $0x3, %ecx
jmp 0xfe032
movq %r14, %rdi
movl $0x28, %esi
movq %rbx, %rdx
callq *0x8(%rax)
xorl %ecx, %ecx
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xfae8b
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq *0x8(%rax)
movq 0x10(%r12), %rsi
testq %r15, %r15
je 0xfe091
movzbl (%rsi), %eax
leaq 0x5c2d4(%rip), %rcx     # 0x15a340
cmpb $0x1, (%rax,%rcx)
jne 0xfe091
cmpb $0x15, %al
jne 0xfe07c
testb $0x1, 0x7(%rsi)
jne 0xfe091
movq %r14, %rdi
movq %rbx, %rdx
movl $0x2, %ecx
movq %r15, %r8
callq 0x9c033
jmp 0xfe0ad
movzbl (%rsi), %eax
leaq 0x5c2e5(%rip), %r9      # 0x15a380
movq %r14, %rdi
movq %rbx, %rdx
movl $0x2, %ecx
movq %r15, %r8
callq *(%r9,%rax,8)
testb %bpl, %bpl
je 0xfe0d9
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %r14, %rdi
movl $0x29, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: slot_to_port_1
static int32_t slot_to_port_1(s7_scheme *sc, s7_pointer x, s7_pointer port, use_write_t use_write, shared_info *ci, int32_t n)
    {
        if (tis_slot(x))
        {
            n = slot_to_port_1(sc, next_slot(x), port, use_write, ci, n);
            if (n <= sc->print_length)
            {
                port_write_character(port)(sc, ' ', port);
                object_to_port_with_circle_check(sc, x, port, use_write, ci);
            }
            else
            {
                if (n == (sc->print_length + 1))
                    port_write_string(port)(sc, " ...", 4, port);
            }
        }
        return(n + 1);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xfe14a
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq 0x18(%rsi), %rsi
callq 0xfe0e8
movl %eax, %ebx
cltq
movq 0x280(%r15), %rcx
cmpq %rax, %rcx
jge 0xfe14e
incq %rcx
cmpq %rax, %rcx
jne 0xfe1b9
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
leaq 0x21957(%rip), %rsi     # 0x11fa91
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rcx
callq *0x10(%rax)
jmp 0xfe1b9
xorl %ebx, %ebx
jmp 0xfe1b9
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %r15, %rdi
movl $0x20, %esi
movq %r14, %rdx
callq *0x8(%rax)
testq %r12, %r12
je 0xfe19b
movzbl (%r13), %eax
leaq 0x5c1cb(%rip), %rcx     # 0x15a340
cmpb $0x1, (%rax,%rcx)
jne 0xfe19b
cmpb $0x15, %al
jne 0xfe186
testb $0x1, 0x7(%r13)
jne 0xfe19b
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r12, %r8
callq 0x9c033
jmp 0xfe1b9
movzbl (%r13), %eax
leaq 0x5c1d9(%rip), %r9      # 0x15a380
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r12, %r8
callq *(%r9,%rax,8)
incl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: collect_locals
static void collect_locals(s7_scheme *sc, s7_pointer body, s7_pointer e, s7_pointer args, s7_int gc_loc)
    { /* currently called only in write_closure_readably */
        if (is_pair(body))
        {
            collect_locals(sc, car(body), e, args, gc_loc);
            collect_locals(sc, cdr(body), e, args, gc_loc);
        }
        else
        {
            if (is_symbol(body))
                collect_symbol(sc, body, e, args, gc_loc);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movzbl (%r12), %eax
cmpl $0x1, %eax
jne 0xfe50b
movq 0x8(%r12), %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xfe4cc
movq 0x10(%r12), %r12
jmp 0xfe4e4
cmpl $0xa, %eax
jne 0xfe52d
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfe6c5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: write_closure_readably_1
static void write_closure_readably_1(s7_scheme *sc, s7_pointer obj, s7_pointer arglist, s7_pointer body, s7_pointer port)
    {
        s7_int old_print_length;
        s7_pointer p;

        if (type(obj) == T_CLOSURE_STAR)
            port_write_string(port)(sc, "(lambda* ", 9, port);
        else port_write_string(port)(sc, "(lambda ", 8, port);

        if ((is_pair(arglist)) &&
                (allows_other_keys(arglist)))
        {
            sc->temp9 = s7_append(sc, arglist, cons(sc, sc->key_allow_other_keys_symbol, sc->nil));
            object_to_port(sc, sc->temp9, port, P_WRITE, NULL);
            sc->temp9 = sc->nil;
        }
        else object_to_port(sc, arglist, port, P_WRITE, NULL); /* here we just want the straight output (a b) not (list 'a 'b) */

        old_print_length = sc->print_length;
        sc->print_length = 1048576;
        for (p = body; is_pair(p); p = cdr(p))
        {
            port_write_character(port)(sc, ' ', port);
            object_to_port(sc, car(p), port, P_WRITE, NULL);
        }
        port_write_character(port)(sc, ')', port);
        sc->print_length = old_print_length;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
cmpb $0x29, (%rsi)
movq %rdi, %r14
movq 0x8(%r8), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
jne 0xfe56d
leaq 0x25460(%rip), %rsi     # 0x1239c6
movl $0x9, %edx
jmp 0xfe579
leaq 0x2545c(%rip), %rsi     # 0x1239d0
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq *%rax
movzbl (%r12), %eax
cmpq $0x1, %rax
jne 0xfe594
testb $0x2, 0x3(%r12)
jne 0xfe5b5
leaq 0x5bde5(%rip), %r9      # 0x15a380
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
jmp 0xfe640
movq 0x1898(%r14), %r13
movq 0x90(%r14), %rax
movq 0x110(%r14), %rbp
cmpq 0x98(%r14), %rax
ja 0xfe5db
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r13, 0x8(%rdx)
movq %rbp, 0x10(%rdx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c191
movq %rax, 0x538(%r14)
movzbl (%rax), %r9d
leaq 0x5bd63(%rip), %r10     # 0x15a380
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r10,%r9,8)
movq 0x110(%r14), %rax
movq %rax, 0x538(%r14)
movq 0x280(%r14), %r12
movq $0x100000, 0x280(%r14) # imm = 0x100000
cmpb $0x1, (%r15)
jne 0xfe699
leaq 0x5bd21(%rip), %r13     # 0x15a380
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq *0x8(%rax)
movq 0x8(%r15), %rsi
movzbl (%rsi), %eax
movq %r14, %rdi
movq %rbx, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r13,%rax,8)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
je 0xfe65f
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movl $0x29, %esi
movq %rbx, %rdx
callq *0x8(%rax)
movq %r12, 0x280(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: collect_symbol
static void collect_symbol(s7_scheme *sc, s7_pointer sym, s7_pointer e, s7_pointer args, s7_int gc_loc)
    {
        if ((!arg_memq(T_Sym(sym), args)) &&
                (!slot_memq(sym, gc_protected_at(sc, gc_loc))))
        {
            s7_pointer slot;
            slot = match_symbol(sc, sym, e);
            if (slot)
                gc_protected_at(sc, gc_loc) = cons(sc, slot, gc_protected_at(sc, gc_loc));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
cmpb $0x1, (%rcx)
sete %al
jne 0xfe6f5
movq 0x8(%rcx), %rdi
cmpq %rsi, %rdi
je 0xfe6f5
cmpb $0x1, (%rdi)
jne 0xfe6ef
cmpq %rsi, 0x8(%rdi)
je 0xfe6f5
movq 0x10(%rcx), %rcx
jmp 0xfe6d3
testb $0x1, %al
jne 0xfe7b2
movq 0xd0(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax,%rbx,8), %r15
cmpb $0x1, (%r15)
sete %al
jne 0xfe738
movq 0x8(%r15), %rcx
cmpq %rsi, 0x8(%rcx)
je 0xfe738
movq %r15, %rcx
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
sete %al
jne 0xfe738
movq 0x8(%rcx), %rdi
cmpq %rsi, 0x8(%rdi)
jne 0xfe722
testb %al, %al
jne 0xfe7b2
cmpb $0x1c, (%rdx)
jne 0xfe75e
movq 0x8(%rdx), %r12
testq %r12, %r12
je 0xfe758
cmpq %rsi, 0x8(%r12)
je 0xfe761
movq 0x18(%r12), %r12
jmp 0xfe745
movq 0x10(%rdx), %rdx
jmp 0xfe73c
xorl %r12d, %r12d
testq %r12, %r12
je 0xfe7b2
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xfe77e
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0xd0(%r14), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx,%rbx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: pair_length
static s7_pointer pair_length(s7_scheme *sc, s7_pointer a)
                {
                    s7_int i;
                    s7_pointer slow, fast;
                    slow = a;
                    fast = a; /* we know a is a pair, don't start with fast = cdr(a)! if a len = 3, we never match */
                    i = 0;
                    while (true)
                    {
                        LOOP_4(fast = cdr(fast); i++; if (!is_pair(fast)) return(make_integer(sc, (is_null(fast)) ? i : -i)));
                        slow = cdr(slow);
                        if (fast == slow)	return(real_infinity);
                    }
                    return(real_infinity);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rsi, %rax
movq 0x10(%rsi), %rcx
cmpb $0x1, (%rcx)
jne 0xfe818
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xfe825
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xfe833
movq 0x10(%rcx), %rsi
cmpb $0x1, (%rsi)
jne 0xfe848
movq 0x10(%rax), %rax
addq $-0x4, %r14
cmpq %rax, %rsi
jne 0xfe7db
movq 0x5768d(%rip), %rax     # 0x155ea0
jmp 0xfe8ae
movl $0x1, %eax
subq %r14, %rax
decq %r14
jmp 0xfe83f
movl $0x2, %eax
subq %r14, %rax
addq $-0x2, %r14
jmp 0xfe83f
movl $0x3, %eax
subq %r14, %rax
addq $-0x3, %r14
cmpq 0x110(%rbx), %rcx
jmp 0xfe85b
movl $0x4, %eax
subq %r14, %rax
addq $-0x4, %r14
cmpq 0x110(%rbx), %rsi
cmoveq %rax, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xfe875
leaq 0x500e1(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0xfe8ae
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfe88d
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: ip_length
static s7_pointer ip_length(s7_scheme *sc, s7_pointer port)
                {
                    if (port_is_closed(port))
                        return(sc->F);             /* or 0? */
                    if (is_string_port(port))
                        return(make_integer(sc, port_data_size(port))); /* length of string we're reading */
#if (!MS_WINDOWS)
                    if (is_file_port(port))
                    {
                        long cur_pos, len;
                        cur_pos = ftell(port_file(port));
                        fseek(port_file(port), 0, SEEK_END);
                        len = ftell(port_file(port));
                        rewind(port_file(port));
                        fseek(port_file(port), cur_pos, SEEK_SET);
                        return(make_integer(sc, len));
                    }
#endif
                    return(sc->F);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpb $0x1, 0x2(%rax)
je 0xfece6
movq %rsi, %r14
movl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0xfecf9
cmpl $0x1, %ecx
jne 0xfece6
movq 0x18(%r14), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xfed5e
leaq 0x4fc70(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0xfeced
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rax), %rdi
callq 0x93a0
movq %rax, %r12
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x9500
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x93a0
movq %rax, %r15
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x91e0
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x9500
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0xfed9c
leaq 0x4fbf8(%rip), %rax     # 0x14e950
movq (%rax,%r15,8), %rax
jmp 0xfeced
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfed76
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xfeced
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfedb4
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
jmp 0xfeced
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: op_length
static s7_pointer op_length(s7_scheme *sc, s7_pointer port)
                {
                    if (port_is_closed(port))
                        return(sc->F);             /* or 0? */
                    if (is_string_port(port))
                        return(make_integer(sc, port_position(port))); /* length of string we've written */
                    return(sc->F);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpb $0x1, 0x2(%rax)
je 0xfee0b
cmpl $0x1, 0x4(%rax)
jne 0xfee0b
movq 0x20(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xfee1a
leaq 0x4fb4b(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0xfee12
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfee32
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xfee12