LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xb99d3
leaq -0x8e59e(%rip), %rax    # 0x2b423
movq %rax, 0x28(%r15)
andb $0x7f, 0x3(%r15)
movq 0x5bd8f(%rip), %rax     # 0x115760
jmp 0xb9a4e
movq %rdi, %rbx
leaq 0x1bf63(%rip), %rcx     # 0xd5940
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
callq 0x94d4
movq %rax, %r14
movq 0x4d8(%rbx), %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb9a58
movq %rax, %r12
movq %r13, 0x4d8(%rbx)
movq 0x10(%r15), %rax
testq %rax, %rax
jne 0xb9a46
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb9a30
movq %rbx, %rdi
callq 0x9c27
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_O2/BernardTatin[P]s7sh/s7.c
// Function: kmg
static s7_pointer kmg(s7_scheme *sc, s7_int bytes)
                {
                    block_t *b;
                    int len = 0;
                    b = mallocate(sc, 128);
                    if (bytes < 1000)
                        len = snprintf((char *)block_data(b), 128, "%" print_s7_int, bytes);
                    else
                    {
                        if (bytes < 1000000)
                            len = snprintf((char *)block_data(b), 128, "%.1fk", bytes / 1000.0);
                        else
                        {
                            if (bytes < 1000000000)
                                len = snprintf((char *)block_data(b), 128, "%.1fM", bytes / 1000000.0);
                            else len = snprintf((char *)block_data(b), 128, "%.1fG", bytes / 1000000000.0);
                        }
                    }
                    return(cons(sc, make_integer(sc, bytes), block_to_string(sc, b, len)));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x80, %esi
callq 0x9037
movq %rax, %r14
cmpq $0x3e7, %r15            # imm = 0x3E7
jg 0xbb93d
movq (%r14), %rdi
leaq 0x2b211(%rip), %rdx     # 0xe6b3d
movl $0x80, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0x8210
jmp 0xbb969
cmpq $0xf423f, %r15          # imm = 0xF423F
ja 0xbb981
movq (%r14), %rdi
cvtsi2sd %r15, %xmm0
divsd 0x167b2(%rip), %xmm0    # 0xd2108
leaq 0x2a2e3(%rip), %rdx     # 0xe5c40
movl $0x80, %esi
movb $0x1, %al
callq 0x8210
movl %eax, %ebp
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0xbb9c1
leaq 0x59fd5(%rip), %rax     # 0x115950
movq (%rax,%r15,8), %r12
jmp 0xbb9fc
xorl %eax, %eax
cmpq $0x3b9aca00, %r15       # imm = 0x3B9ACA00
setb %al
cvtsi2sd %r15, %xmm0
leaq 0x2a2ad(%rip), %rcx     # 0xe5c46
leaq 0x2a2ac(%rip), %rdx     # 0xe5c4c
cmovbq %rcx, %rdx
movq (%r14), %rdi
leaq 0x1a5c2(%rip), %rcx     # 0xd5f70
divsd (%rcx,%rax,8), %xmm0
movl $0x80, %esi
movb $0x1, %al
callq 0x8210
movl %eax, %ebp
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xbb9e0
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0xb, (%r12)
movq %r15, 0x8(%r12)
movslq %ebp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bf22
movq %rax, %r14
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xbba2c
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x8(%rdi), %rdi
callq 0x72838
movq 0x10(%rbx), %rdi
callq 0x72838
movq 0x18(%rbx), %rdi
callq 0x7284e
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x72838
// File: /workspace/github_c_makefile_star2_O2/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 0xbbabe
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x3, %rsi
callq 0x728c1
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x72838
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x8(%rdi), %rdi
callq 0x72838
movq 0x10(%rbx), %rdi
callq 0x72838
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x72838
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: mark_hash_table
static void mark_hash_table(s7_pointer p)
    {
        set_mark(p);
        gc_mark(hash_table_procedures(p));
        if (hash_table_entries(p) > 0)
        {
            s7_int len;
            hash_entry_t **entries, **last;

            entries = hash_table_elements(p);
            len = hash_table_mask(p) + 1;
            last = (hash_entry_t **)(entries + len);

            if ((is_weak_hash_table(p)) &&
                    (weak_hash_iters(p) == 0))
            {
                while (entries < last)
                {
                    hash_entry_t *xp;
                    for (xp = *entries++; xp; xp = hash_entry_next(xp))
                        gc_mark(hash_entry_value(xp));
                    for (xp = *entries++; xp; xp = hash_entry_next(xp))
                        gc_mark(hash_entry_value(xp));
                }
            }
            else
            {
                while (entries < last) /* counting entries here was slightly faster */
                {
                    hash_entry_t *xp;
                    for (xp = *entries++; xp; xp = hash_entry_next(xp))
                    {
                        gc_mark(hash_entry_key(xp));
                        gc_mark(hash_entry_value(xp));
                    }
                    for (xp = *entries++; xp; xp = hash_entry_next(xp))
                    {
                        gc_mark(hash_entry_key(xp));
                        gc_mark(hash_entry_value(xp));
                    }}}}
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x28(%rdi), %rax
movq 0x20(%rax), %rdi
callq 0x72838
movq 0x28(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jle 0xbbc12
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %r14
leaq (%r14,%rcx,8), %r15
addq $0x8, %r15
testb $0x8, 0x3(%rbx)
je 0xbbc0d
cmpl $0x0, 0xc(%rax)
jne 0xbbc0d
cmpq %r15, %r14
jae 0xbbc12
movq %r14, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xbbba3
movq 0x20(%rbx), %rdi
callq 0x72838
addq $0x18, %rbx
jmp 0xbbb8c
leaq 0x8(%r14), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xbbbbe
movq 0x20(%rbx), %rdi
callq 0x72838
addq $0x18, %rbx
jmp 0xbbba7
addq $0x10, %r14
jmp 0xbbb80
movq %r14, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xbbbe6
movq (%rbx), %rdi
callq 0x72838
movq 0x20(%rbx), %rdi
callq 0x72838
addq $0x18, %rbx
jmp 0xbbbc7
leaq 0x8(%r14), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xbbc09
movq (%rbx), %rdi
callq 0x72838
movq 0x20(%rbx), %rdi
callq 0x72838
addq $0x18, %rbx
jmp 0xbbbea
addq $0x10, %r14
cmpq %r15, %r14
jb 0xbbbc4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x72838
testb $0x4, 0x3(%rbx)
jne 0xbbc31
popq %rbx
retq
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x72838
// File: /workspace/github_c_makefile_star2_O2/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 0xc012a
cmpq %r15, 0x128(%r14)
je 0xc012a
leaq 0x2672f(%rip), %rsi     # 0xe681d
pushq $0x19
popq %rdx
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 0x26712(%rip), %rsi     # 0xe6837
pushq $0x7
popq %rdx
jmp 0xc0132
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_O2/BernardTatin[P]s7sh/s7.c
// Function: eof_to_port
static void eof_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        /* if file has #<eof> it causes read to return #<eof> -> end of read! what is readable version? '#<eof> or (begin #<eof>) as below
         * but this is silly -- to fool read, the #<eof> has to be all by itself at the top-level!
         * and the read of #<eof> does not affect the port, so if you know it's there, just ignore #<eof> and continue reading.
         */
        if (use_write == P_READABLE)
            port_write_string(port)(sc, "(begin #<eof>)", 14, port);
        else port_write_string(port)(sc, unique_name(obj), unique_name_length(obj), port);
    }

// Assembly:
movl %ecx, %eax
movq %rdx, %rcx
movq 0x8(%rdx), %rdx
movq 0x48(%rdx), %rdx
movq 0x10(%rdx), %r8
cmpl $0x2, %eax
jne 0xc0162
leaq 0x266e3(%rip), %rsi     # 0xe683f
pushq $0xe
popq %rdx
jmpq *%r8
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rdx
movq %rax, %rsi
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: integer_to_port
static void integer_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        if (has_print_name(obj))
        {
            if (is_string_port(port))
            {
                if (port_position(port) + print_name_length(obj) < port_data_size(port))
                {
                    memcpy((void *)(port_data(port) + port_position(port)), (void *)print_name(obj), print_name_length(obj));
                    port_position(port) += print_name_length(obj);
                }
                else string_write_string_resized(sc, print_name(obj), print_name_length(obj), port);
            }
            else port_write_string(port)(sc, print_name(obj), print_name_length(obj), port);
        }
        else
        {
            s7_int nlen;
            char *str;
            str = integer_to_string(sc, integer(obj), &nlen);
            set_print_name(obj, str, nlen);
            port_write_string(port)(sc, str, nlen, port);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testb $0x8, 0x3(%rsi)
jne 0xc06ed
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x73b88
movq %rax, %r13
movq (%r12), %r12
movq %r14, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0xc3136
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rax
cmpl $0x1, 0x4(%rax)
jne 0xc0722
movq 0x20(%rbx), %rdi
movzbl 0x18(%r14), %edx
leaq (%rdi,%rdx), %rax
cmpq 0x18(%rbx), %rax
jge 0xc074b
addq 0x10(%rbx), %rdi
leaq 0x19(%r14), %rsi
callq 0x83e0
movzbl 0x18(%r14), %eax
addq %rax, 0x20(%rbx)
jmp 0xc06df
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movzbl 0x18(%r14), %edx
addq $0x19, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
addq $0x19, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7736d
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testb $0x8, 0x3(%rsi)
jne 0xc0813
leaq 0x8(%rsp), %r13
andq $0x0, (%r13)
movslq 0x468(%r14), %rcx
pushq $0x67
popq %r8
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %r9
callq 0x730a4
movq %rax, %r12
movq (%r13), %r13
cmpq $0x15, %r13
jg 0xc07fc
movzbl (%r12), %eax
cmpl $0x69, %eax
je 0xc07fc
cmpl $0x6e, %eax
je 0xc07fc
cmpb $0xe, (%r15)
jne 0xc07ee
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq 0x10(%r15), %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jg 0xc07fc
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0xc3136
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
jmp 0xc082e
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 $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 0xc145b
movq 0x8(%r15), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x94d4
movq 0x8(%rax), %rcx
movq 0x20(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpb $0x20, (%rcx)
jne 0xc145b
testb $0x1, 0x2(%rax)
jne 0xc145b
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
leaq 0x256c3(%rip), %rsi     # 0xe6af9
pushq $0x2
popq %rdx
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 0xc1483
movq 0x8(%r15), %rcx
movslq 0x8(%rcx), %rdx
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
testq %rdx, %rdx
jle 0xc1479
movq (%rcx), %rsi
jmp 0xc1483
leaq 0x2567c(%rip), %rsi     # 0xe6afc
pushq $0x15
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: slot_to_port
static void slot_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        /* the slot symbol might need (symbol...) in which case we don't want the preceding quote */
        symbol_to_port(sc, slot_symbol(obj), port, P_READABLE, ci);
        port_write_character(port)(sc, ' ', port);
        object_to_port_with_circle_check(sc, slot_value(obj), port, use_write, ci);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rsi), %rsi
pushq $0x2
popq %rcx
callq 0xc0840
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
pushq $0x20
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq *0x8(%rax)
movq 0x10(%r12), %rsi
movzbl (%rsi), %eax
testq %rbx, %rbx
je 0xc1ecc
leaq 0x5f4a0(%rip), %rcx     # 0x121340
cmpb $0x1, (%rax,%rcx)
jne 0xc1ecc
cmpl $0x15, %eax
jne 0xc1eb1
testb $0x1, 0x7(%rsi)
jne 0xc1ec9
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x77872
pushq $0x15
popq %rax
leaq 0x5f4ad(%rip), %rcx     # 0x121380
movq (%rcx,%rax,8), %rax
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 0xc23f9
movq %r15, %rax
cqto
idivq %r12
decl %r8d
movq %r14, %rdi
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0xc23b3
movq %r15, %rax
cqto
idivq %r12
movq %r14, %rdi
movq %rdx, %rsi
callq 0x91f9
leaq 0x24143(%rip), %rdx     # 0xe6556
movl $0x80, %esi
movq %rbx, %rdi
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x90f7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: pos_int_to_str_direct_1
static char *pos_int_to_str_direct_1(s7_scheme *sc, s7_int num)
    {
        char *p;
        p = (char *)(sc->int_to_str5 + INT_TO_STR_SIZE - 1);
        *p-- = '\0';
        do {*p-- = "0123456789"[num % 10]; num /= 10;} while (num);
        return((char *)(p + 1));
    }

// Assembly:
movb $0x0, 0xb8f(%rdi)
addq $0xb8f, %rdi            # imm = 0xB8F
leaq 0x20094(%rip), %rcx     # 0xe24e0
pushq $0xa
popq %r8
movq %rsi, %rax
cqto
idivq %r8
movb (%rdx,%rcx), %dl
movb %dl, -0x1(%rdi)
decq %rdi
addq $0x9, %rsi
cmpq $0x12, %rsi
movq %rax, %rsi
ja 0xc2450
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: write_vector_dimensions
static void write_vector_dimensions(s7_scheme *sc, s7_pointer vect, s7_pointer port)
    {
        char buf[128];
        s7_int dim, plen;
        port_write_string(port)(sc, " '(", 3, port);
        for (dim = 0; dim < vector_ndims(vect) - 1; dim++)
        {
            plen = catstrs_direct(buf, integer_to_string_no_length(sc, vector_dimension(vect, dim)), " ", NULL);
            port_write_string(port)(sc, buf, plen, port);
        }
        plen = catstrs_direct(buf, integer_to_string_no_length(sc, vector_dimension(vect, dim)), "))", NULL);
        port_write_string(port)(sc, buf, plen, port);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdx), %rax
movq 0x48(%rax), %rax
leaq 0x24078(%rip), %rsi     # 0xe6513
pushq $0x3
popq %rdx
movq %rbx, %rcx
callq *0x10(%rax)
movq %rsp, %r13
xorl %ebp, %ebp
movq 0x18(%r15), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq 0x10(%rax), %r12
decq %r12
movq (%rcx,%rbp,8), %rsi
movq %r14, %rdi
callq 0x73af1
cmpq %r12, %rbp
jge 0xc24ff
movq %r13, %rdi
movq %rax, %rsi
leaq 0x2407d(%rip), %rdx     # 0xe6556
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xb3a5
movq 0x8(%rbx), %rcx
movq 0x48(%rcx), %r8
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq *0x10(%r8)
incq %rbp
jmp 0xc24a9
leaq 0x24144(%rip), %rdx     # 0xe664a
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xb3a5
movq 0x8(%rbx), %rcx
movq 0x48(%rcx), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq *0x10(%r8)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: string_needs_slashification
static bool string_needs_slashification(const char *str, s7_int len)
    {
        /* we have to go by len (str len) not *s==0 because s7 strings can have embedded nulls */
        uint8_t *p, *pend;
        pend = (uint8_t *)(str + len);
        for (p = (uint8_t *)str; p < pend; p++)
            if (slashify_table[*p])
                return(true);
        return(false);
    }

// Assembly:
addq %rdi, %rsi
leaq 0x6255e(%rip), %rax     # 0x124d60
movq %rdi, %rcx
cmpq %rsi, %rdi
jae 0xc2817
movzbl (%rcx), %edx
leaq 0x1(%rcx), %rdi
cmpb $0x1, (%rdx,%rax)
jne 0xc2802
cmpq %rsi, %rcx
setb %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq $0x8, %r15
pushq $0x2
popq %r13
pushq $0x29
popq %rbp
movq (%r15), %r15
testq %r15, %r15
je 0xc2f14
testb $0x4, 0x2(%r15)
je 0xc2f0b
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %r12, %rdi
leaq 0x2399b(%rip), %rsi     # 0xe680d
pushq $0xf
popq %rdx
movq %r14, %rcx
callq *0x10(%rax)
movq 0x8(%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xc0840
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %r12, %rdi
leaq 0x238b7(%rip), %rsi     # 0xe6755
pushq $0x2
popq %rdx
movq %r14, %rcx
callq *0x10(%rax)
movq 0x28(%r15), %rsi
movzbl (%rsi), %eax
testq %rbx, %rbx
je 0xc2ee1
leaq 0x5e486(%rip), %rcx     # 0x121340
cmpb $0x1, (%rax,%rcx)
jne 0xc2ee1
cmpl $0x15, %eax
jne 0xc2ece
testb $0x1, 0x7(%rsi)
pushq $0x15
popq %rax
jne 0xc2ee1
movq %r12, %rdi
movq %r14, %rdx
movl %r13d, %ecx
movq %rbx, %r8
callq 0x77872
jmp 0xc2ef8
movq %r12, %rdi
movq %r14, %rdx
movl %r13d, %ecx
movq %rbx, %r8
leaq 0x5e48c(%rip), %r9      # 0x121380
callq *(%r9,%rax,8)
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq *0x8(%rax)
addq $0x18, %r15
jmp 0xc2e49
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0xc3047
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 0xc2f23
testb %r13b, %r13b
je 0xc2f80
cmpq $0x0, 0x18(%r12)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
je 0xc2f99
leaq 0x23670(%rip), %rsi     # 0xe65e2
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq *0x10(%rax)
jmp 0xc2fa5
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
pushq $0x20
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq *0x8(%rax)
pushq $0x3
popq %rcx
jmp 0xc2fa7
pushq $0x28
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq *0x8(%rax)
xorl %ecx, %ecx
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xc0840
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
pushq $0x20
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq *0x8(%rax)
movq 0x10(%r12), %rsi
movzbl (%rsi), %eax
testq %r15, %r15
je 0xc3006
leaq 0x5e361(%rip), %rcx     # 0x121340
cmpb $0x1, (%rax,%rcx)
jne 0xc3006
cmpl $0x15, %eax
jne 0xc2ff0
testb $0x1, 0x7(%rsi)
jne 0xc3003
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %r8
callq 0x77872
jmp 0xc301d
pushq $0x15
popq %rax
leaq 0x5e373(%rip), %r9      # 0x121380
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %r8
callq *(%r9,%rax,8)
testb %bpl, %bpl
je 0xc3047
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
pushq $0x29
popq %rsi
movq %r14, %rdi
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_O2/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 0xc30b7
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq 0x18(%rsi), %rsi
callq 0xc3056
movl %eax, %ebx
cltq
movq 0x280(%r12), %rcx
cmpq %rax, %rcx
jge 0xc30bb
incq %rcx
cmpq %rax, %rcx
jne 0xc3123
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
leaq 0x1fa98(%rip), %rsi     # 0xe2b41
pushq $0x4
popq %rdx
movq %r12, %rdi
movq %r14, %rcx
callq *0x10(%rax)
jmp 0xc3123
xorl %ebx, %ebx
jmp 0xc3123
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
pushq $0x20
popq %rsi
movq %r12, %rdi
movq %r14, %rdx
callq *0x8(%rax)
movzbl (%r13), %eax
testq %r15, %r15
je 0xc310a
leaq 0x5e260(%rip), %rcx     # 0x121340
cmpb $0x1, (%rax,%rcx)
jne 0xc310a
cmpl $0x15, %eax
jne 0xc30f2
testb $0x1, 0x7(%r13)
jne 0xc3107
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r15, %r8
callq 0x77872
jmp 0xc3123
pushq $0x15
popq %rax
leaq 0x5e26f(%rip), %r9      # 0x121380
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r15, %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_O2/BernardTatin[P]s7sh/s7.c
// Function: set_print_name
static void set_print_name(s7_pointer p, const char *name, int32_t len)
    {
        if ((len < (PRINT_NAME_SIZE - 1)) &&
                (!is_mutable_number(p)))
        {
            set_has_print_name(p);
            print_name_length(p) = (uint8_t)len;
            memcpy((void *)print_name(p), (void *)name, len);
            (print_name(p))[len] = 0;
        }
    }

// Assembly:
cmpl $0x14, %edx
jg 0xc3173
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
btl $0x1a, %eax
jb 0xc316c
orq $0x8000000, %rax        # imm = 0x8000000
movq %rax, (%rbx)
movb %dl, 0x18(%rbx)
leaq 0x19(%rbx), %rdi
movslq %edx, %r14
movq %r14, %rdx
callq 0x83e0
movb $0x0, 0x19(%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc348f
movq 0x8(%r12), %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xc3450
movq 0x10(%r12), %r12
jmp 0xc3468
cmpl $0xa, %eax
jne 0xc34b1
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 0xc363e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc34ee
leaq 0x2358c(%rip), %rsi     # 0xe6a76
pushq $0x9
jmp 0xc34f7
leaq 0x2358b(%rip), %rsi     # 0xe6a80
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq *%rax
movzbl (%r12), %eax
cmpq $0x1, %rax
jne 0xc3513
testb $0x2, 0x3(%r12)
jne 0xc3532
leaq 0x5de66(%rip), %r9      # 0x121380
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
jmp 0xc35bb
movq 0x1898(%r14), %r13
movq 0x90(%r14), %rax
movq 0x110(%r14), %rbp
cmpq 0x98(%r14), %rax
ja 0xc355f
movq %r14, %rdi
callq 0x9c27
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 0x2d9df
movq %rax, 0x538(%r14)
movzbl (%rax), %r9d
leaq 0x5dde6(%rip), %r10     # 0x121380
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
xorl %r8d, %r8d
callq *(%r10,%r9,8)
movq 0x110(%r14), %rax
movq %rax, 0x538(%r14)
movq 0x280(%r14), %rax
movq %rax, (%rsp)
movq $0x100000, 0x280(%r14) # imm = 0x100000
pushq $0x20
popq %rbp
leaq 0x5dda5(%rip), %r13     # 0x121380
pushq $0x1
popq %r12
cmpb $0x1, (%r15)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
jne 0xc3619
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq *%rax
movq 0x8(%r15), %rsi
movzbl (%rsi), %eax
movq %r14, %rdi
movq %rbx, %rdx
movl %r12d, %ecx
xorl %r8d, %r8d
callq *(%r13,%rax,8)
movq 0x10(%r15), %r15
jmp 0xc35df
pushq $0x29
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq *%rax
movq (%rsp), %rax
movq %rax, 0x280(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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)
jne 0xc3673
movq 0x8(%rcx), %rax
cmpq %rsi, %rax
je 0xc370b
cmpb $0x1, (%rax)
jne 0xc366d
cmpq %rsi, 0x8(%rax)
je 0xc370b
movq 0x10(%rcx), %rcx
jmp 0xc364c
movq 0xd0(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax,%rbx,8), %r15
movq %r15, %rax
cmpb $0x1, (%rax)
jne 0xc36b8
movq 0x8(%rax), %rcx
cmpq %rsi, 0x8(%rcx)
je 0xc370b
movq 0x10(%rax), %rax
jmp 0xc3685
leaq 0x8(%rdx), %r12
movq (%r12), %r12
testq %r12, %r12
je 0xc36b4
cmpq %rsi, 0x8(%r12)
je 0xc36bf
addq $0x18, %r12
jmp 0xc369e
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xc369a
jmp 0xc370b
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xc36de
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %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_O2/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 0xc379d
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xc37a8
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xc37b4
movq 0x10(%rcx), %rsi
cmpb $0x1, (%rsi)
jne 0xc37c7
movq 0x10(%rax), %rax
addq $-0x4, %r14
cmpq %rax, %rsi
jne 0xc3760
movq 0x59708(%rip), %rax     # 0x11cea0
jmp 0xc382b
pushq $0x1
popq %rax
subq %r14, %rax
decq %r14
jmp 0xc37be
pushq $0x2
popq %rax
subq %r14, %rax
addq $-0x2, %r14
jmp 0xc37be
pushq $0x3
popq %rax
subq %r14, %rax
addq $-0x3, %r14
cmpq 0x110(%rbx), %rcx
jmp 0xc37d8
pushq $0x4
popq %rax
subq %r14, %rax
addq $-0x4, %r14
cmpq 0x110(%rbx), %rsi
cmoveq %rax, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xc37f2
leaq 0x52164(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0xc382b
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc3811
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0xc3c65
movq %rsi, %r14
movl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0xc3c78
cmpl $0x1, %ecx
jne 0xc3c65
movq 0x18(%r14), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xc3cdb
leaq 0x51cf1(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0xc3c6c
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rax), %rdi
callq 0x83a0
movq %rax, %r12
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x8500
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x83a0
movq %rax, %r15
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x81e0
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x8500
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0xc3d19
leaq 0x51c7b(%rip), %rax     # 0x115950
movq (%rax,%r15,8), %rax
jmp 0xc3c6c
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc3cfa
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xc3c6c
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc3d38
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
jmp 0xc3c6c
// File: /workspace/github_c_makefile_star2_O2/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 0xc3d88
cmpl $0x1, 0x4(%rax)
jne 0xc3d88
movq 0x20(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xc3d97
leaq 0x51bce(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0xc3d8f
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xc3db6
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xc3d8f
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_pointer_equal
static bool c_pointer_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    shared_info *nci = ci;
                    if (x == y) return(true);
                    if (!s7_is_c_pointer(y)) return(false);
                    if (c_pointer(x) != c_pointer(y)) return(false);
                    if (c_pointer_type(x) != c_pointer_type(y))
                    {
                        if (!nci) nci = new_shared_info(sc);
                        if (!s7_is_equal_1(sc, c_pointer_type(x), c_pointer_type(y), nci))
                            return(false);
                    }
                    if (c_pointer_info(x) != c_pointer_info(y))
                    {
                        if (!nci) nci = new_shared_info(sc);
                        if (!s7_is_equal_1(sc, c_pointer_info(x), c_pointer_info(y), nci))
                            return(false);
                    }
                    return(true);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb $0x1, %bl
cmpq %rdx, %rsi
je 0xc3e01
movq %rdx, %r12
cmpb $0x21, (%rdx)
jne 0xc3dff
movq %rsi, %r13
movq 0x8(%rsi), %rax
cmpq 0x8(%r12), %rax
je 0xc3e0d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rcx, %r15
movq %rdi, %r14
movq 0x10(%r13), %rsi
movq 0x10(%r12), %rdx
cmpq %rdx, %rsi
je 0xc3e52
testq %r15, %r15
jne 0xc3e3a
movq %r14, %rdi
callq 0x77cff
movq %rax, %r15
movq 0x10(%r13), %rsi
movq 0x10(%r12), %rdx
movzbl (%rsi), %eax
leaq 0x5dedc(%rip), %r8      # 0x121d20
movq %r14, %rdi
movq %r15, %rcx
callq *(%r8,%rax,8)
testb %al, %al
je 0xc3dff
movq 0x18(%r13), %rsi
movq 0x18(%r12), %rdx
cmpq %rdx, %rsi
je 0xc3e01
testq %r15, %r15
jne 0xc3e79
movq %r14, %rdi
callq 0x77cff
movq %rax, %r15
movq 0x18(%r13), %rsi
movq 0x18(%r12), %rdx
movzbl (%rsi), %eax
leaq 0x5de9d(%rip), %r8      # 0x121d20
movq %r14, %rdi
movq %r15, %rcx
callq *(%r8,%rax,8)
testb %al, %al
je 0xc3dff
jmp 0xc3e01
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: rng_equal
static bool rng_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    return(x == y);
#else
                    return((x == y) ||
                            ((is_random_state(y)) &&
                             (random_seed(x) == random_seed(y)) &&
                             (random_carry(x) == random_carry(y))));
#endif
                }

// Assembly:
cmpq %rdx, %rsi
je 0xc40d9
cmpb $0x24, (%rdx)
jne 0xc40d6
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
jne 0xc40d6
movq 0x10(%rsi), %rax
cmpq 0x10(%rdx), %rax
sete %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: closure_equal
static bool closure_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    if (x == y)
                        return(true);
                    if (type(x) != type(y))
                        return(false);
                    if ((has_active_methods(sc, x)) &&
                            (has_active_methods(sc, y)))
                    {
                        s7_pointer equal_func;
                        equal_func = find_method(sc, closure_let(x), sc->is_equal_symbol);
                        if (equal_func != sc->undefined)
                            return(s7_boolean(sc, s7_apply_function(sc, equal_func, list_2(sc, x, y))));
                    }
                    return(false);
                }

// Assembly:
cmpq %rdx, %rsi
je 0xc41df
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movb (%rsi), %al
cmpb (%rdx), %al
jne 0xc41d3
testb $0x40, 0x3(%r14)
je 0xc41d3
movq %rdi, %rbx
cmpb $0x1, 0x24c(%rdi)
jne 0xc41d3
testb $0x40, 0x3(%r15)
je 0xc41d3
movq 0x18(%r14), %rsi
movq 0x1070(%rbx), %rdx
movq %rbx, %rdi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0xc41d3
movq %rax, %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xc417c
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r14, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa34c
cmpq %rax, 0x120(%rbx)
setne %al
jmp 0xc41d5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: fraction_equal
static bool fraction_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_numbers_are_eqv(x, y));
#endif
                    return((s7_is_ratio(y)) &&
                            (numerator(x) == numerator(y)) &&
                            (denominator(x) == denominator(y)));
                }

// Assembly:
cmpb $0xc, (%rdx)
jne 0xc4792
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
jne 0xc4792
movq 0x10(%rsi), %rax
cmpq 0x10(%rdx), %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: real_equal
static bool real_equal(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
#if WITH_GMP
                    if (is_big_number(y))
                        return(big_numbers_are_eqv(x, y));
#endif
                    return((is_t_real(y)) &&
                            (real(x) == real(y)));
                }

// Assembly:
cmpb $0xd, (%rdx)
jne 0xc47ae
movsd 0x8(%rdx), %xmm0
cmpeqsd 0x8(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq