LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xe9539
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 0xe954f
cmpq %r12, %r13
jne 0xe9504
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 0xe952c
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 0xe947f
testl %eax, %eax
js 0xe9554
movl %eax, %edx
incq %rbx
movq 0x10(%rbp), %rbp
cmpq (%r14,%r12,8), %rbx
jl 0xe94c4
movq 0x8(%rsp), %rax
cmpq 0x110(%rax), %rbp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %edx, %eax
jmp 0xe9554
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_O3/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 0xe959a
leaq -0xb1e6a(%rip), %rax    # 0x3771e
movq %rax, 0x28(%r15)
andb $0x7f, 0x3(%r15)
movq 0x5d1c8(%rip), %rax     # 0x146760
jmp 0xe9615
movq %rdi, %rbx
leaq 0x2039c(%rip), %rcx     # 0x109940
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
callq 0x9afc
movq %rax, %r14
movq 0x4d8(%rbx), %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe961f
movq %rax, %r12
movq %r13, 0x4d8(%rbx)
movq 0x10(%r15), %rax
testq %rax, %rax
jne 0xe960d
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe95f7
movq %rbx, %rdi
callq 0xa550
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_O3/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
movq (%rdi), %rax
testq %rax, %rax
js 0xeb959
movzbl %al, %eax
leaq 0x5ae1a(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xeb972
movzbl %al, %eax
leaq 0x5ae01(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq 0x18(%rbx), %rdi
callq 0x8e98b
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xeb995
movzbl %al, %eax
leaq 0x5addf(%rip), %rcx     # 0x146770
popq %rbx
jmpq *(%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeb9ba
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x3, %rsi
callq 0x8eb3a
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xeb9d4
movzbl %al, %eax
leaq 0x5ada0(%rip), %rcx     # 0x146770
popq %rbx
jmpq *(%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq (%rdi), %rax
testq %rax, %rax
js 0xeba61
movzbl %al, %eax
leaq 0x5ad12(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xeba7a
movzbl %al, %eax
leaq 0x5acf9(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xeba94
movzbl %al, %eax
leaq 0x5ace0(%rip), %rcx     # 0x146770
popq %rbx
jmpq *(%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
orq (%rdi), %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0xebc07
movzbl %cl, %eax
leaq 0x5ab6f(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq (%rbx), %rax
btl $0x1a, %eax
jae 0xebc27
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xebc27
movzbl %al, %eax
leaq 0x5ab4d(%rip), %rcx     # 0x146770
popq %rbx
jmpq *(%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
orb $-0x80, 0x7(%rdi)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xebc53
movzbl %al, %eax
leaq 0x5ab20(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xebc6c
movzbl %al, %eax
leaq 0x5ab07(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0xebc86
movzbl %al, %eax
leaq 0x5aaee(%rip), %rcx     # 0x146770
popq %rbx
jmpq *(%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf176d
cmpq %r15, 0x128(%r14)
je 0xf176d
leaq 0x29150(%rip), %rsi     # 0x11a87d
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 0x29131(%rip), %rsi     # 0x11a897
movl $0x7, %edx
jmp 0xf1775
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_O3/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 0x24837(%rip), %rcx     # 0x116540
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 0xf1d13
leaq 0x28d2a(%rip), %rsi     # 0x11aa7e
leaq 0x28de6(%rip), %rcx     # 0x11ab41
movq %rsp, %r15
movq %r15, %rdi
movq %r8, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xc442
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_O3/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 0xf1fee
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 0x8f49e
movq %rax, %r12
movq (%r13), %r13
cmpq $0x15, %r13
jg 0xf1fd7
movzbl (%r12), %eax
cmpl $0x69, %eax
je 0xf1fd7
cmpl $0x6e, %eax
jne 0xf201c
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
jmp 0xf2009
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 0xf204c
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq 0x10(%r15), %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
setl %al
cmpl $0x14, %r13d
jg 0xf1fd7
testb %al, %al
jne 0xf2052
jmp 0xf1fd7
cmpl $0x14, %r13d
jg 0xf1fd7
movq (%r15), %rax
btl $0x1a, %eax
jb 0xf1fd7
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 0x83e0
movb $0x0, 0x19(%r15,%rbp)
jmp 0xf1fd7
// File: /workspace/github_c_makefile_star2_O3/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 0xf2eb3
movq 0x8(%r15), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x9afc
movq 0x8(%rax), %rcx
movq 0x20(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpb $0x20, (%rcx)
jne 0xf2eb3
testb $0x1, 0x2(%rax)
jne 0xf2eb3
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
leaq 0x27ccd(%rip), %rsi     # 0x11ab59
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 0xf2edd
movq 0x8(%r15), %rcx
movslq 0x8(%rcx), %rdx
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
testq %rdx, %rdx
jle 0xf2ed1
movq (%rcx), %rsi
jmp 0xf2edd
leaq 0x27c84(%rip), %rsi     # 0x11ab5c
movl $0x15, %edx
movq %r14, %rdi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x2, %ecx
callq 0xf2089
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %r15, %rdi
movl $0x20, %esi
movq %r14, %rdx
callq *0x8(%rax)
movq 0x10(%r12), %rsi
movzbl (%rsi), %eax
testq %rbx, %rbx
je 0xf3c07
leaq 0x5e767(%rip), %rcx     # 0x152340
cmpb $0x1, (%rax,%rcx)
jne 0xf3c07
cmpl $0x15, %eax
jne 0xf3bef
movl $0x15, %eax
testb $0x1, 0x7(%rsi)
jne 0xf3c07
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9596b
leaq 0x5e772(%rip), %rcx     # 0x152380
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_O3/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 0xf43ba
movq %r15, %rax
cqto
idivq %r12
decl %r8d
movq %r14, %rdi
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0xf4374
movq %r15, %rax
cqto
idivq %r12
movq %rdx, %rcx
movb $0x0, 0xb6f(%r14)
addq $0xb6f, %r14            # imm = 0xB6F
leaq 0x22165(%rip), %rsi     # 0x116540
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 0xf43e5
leaq 0x26190(%rip), %rdx     # 0x11a5b6
movl $0x80, %esi
movq %rbx, %rdi
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x9517
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0xf5214
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x25727(%rip), %r12     # 0x11a86d
leaq 0x25668(%rip), %r13     # 0x11a7b5
testb $0x4, 0x2(%rbp)
je 0xf5207
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 0xf2089
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
movzbl (%rsi), %eax
testq %rbx, %rbx
je 0xf51d8
leaq 0x5d193(%rip), %rcx     # 0x152340
cmpb $0x1, (%rax,%rcx)
jne 0xf51d8
cmpl $0x15, %eax
jne 0xf51c3
movl $0x15, %eax
testb $0x1, 0x7(%rsi)
jne 0xf51d8
movq %r15, %rdi
movq %r14, %rdx
movl $0x2, %ecx
movq %rbx, %r8
callq 0x9596b
jmp 0xf51f1
movq %r15, %rdi
movq %r14, %rdx
movl $0x2, %ecx
movq %rbx, %r8
leaq 0x5d193(%rip), %r9      # 0x152380
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 0xf514d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0xf5359
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 0xf5223
testb %r13b, %r13b
je 0xf5282
cmpq $0x0, 0x18(%r12)
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
je 0xf529f
leaq 0x253d0(%rip), %rsi     # 0x11a642
movl $0x2, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq *0x10(%rax)
jmp 0xf52ad
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq *0x8(%rax)
movl $0x3, %ecx
jmp 0xf52af
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 0xf2089
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq *0x8(%rax)
movq 0x10(%r12), %rsi
movzbl (%rsi), %eax
testq %r15, %r15
je 0xf5314
leaq 0x5d057(%rip), %rcx     # 0x152340
cmpb $0x1, (%rax,%rcx)
jne 0xf5314
cmpl $0x15, %eax
jne 0xf52ff
movl $0x15, %eax
testb $0x1, 0x7(%rsi)
jne 0xf5314
movq %r14, %rdi
movq %rbx, %rdx
movl $0x2, %ecx
movq %r15, %r8
callq 0x9596b
jmp 0xf532d
leaq 0x5d065(%rip), %r9      # 0x152380
movq %r14, %rdi
movq %rbx, %rdx
movl $0x2, %ecx
movq %r15, %r8
callq *(%r9,%rax,8)
testb %bpl, %bpl
je 0xf5359
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_O3/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 0xf53ca
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq 0x18(%rsi), %rsi
callq 0xf5368
movl %eax, %ebx
cltq
movq 0x280(%r15), %rcx
cmpq %rax, %rcx
jge 0xf53ce
incq %rcx
cmpq %rax, %rcx
jne 0xf543a
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
leaq 0x217e7(%rip), %rsi     # 0x116ba1
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rcx
callq *0x10(%rax)
jmp 0xf543a
xorl %ebx, %ebx
jmp 0xf543a
movq 0x8(%r14), %rax
movq 0x48(%rax), %rax
movq %r15, %rdi
movl $0x20, %esi
movq %r14, %rdx
callq *0x8(%rax)
movzbl (%r13), %eax
testq %r12, %r12
je 0xf5421
leaq 0x5cf4b(%rip), %rcx     # 0x152340
cmpb $0x1, (%rax,%rcx)
jne 0xf5421
cmpl $0x15, %eax
jne 0xf540c
movl $0x15, %eax
testb $0x1, 0x7(%r13)
jne 0xf5421
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %r12, %r8
callq 0x9596b
jmp 0xf543a
leaq 0x5cf58(%rip), %r9      # 0x152380
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_O3/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 0xf578c
movq 0x8(%r12), %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0xf574d
movq 0x10(%r12), %r12
jmp 0xf5765
cmpl $0xa, %eax
jne 0xf57ae
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 0xf5947
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %r14
movq 0x8(%r8), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x29, %sil
jne 0xf57ef
leaq 0x252ee(%rip), %rsi     # 0x11aad6
movl $0x9, %edx
jmp 0xf57fb
leaq 0x252ea(%rip), %rsi     # 0x11aae0
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq *%rax
movzbl (%r12), %eax
cmpq $0x1, %rax
jne 0xf5816
testb $0x2, 0x3(%r12)
jne 0xf5837
leaq 0x5cb63(%rip), %r9      # 0x152380
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
jmp 0xf58c2
movq 0x1898(%r14), %r13
movq 0x90(%r14), %rax
movq 0x110(%r14), %rbp
cmpq 0x98(%r14), %rax
ja 0xf5864
movq %r14, %rdi
callq 0xa550
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 0x39c05
movq %rax, 0x538(%r14)
movzbl (%rax), %r9d
leaq 0x5cae1(%rip), %r10     # 0x152380
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 0xf591b
leaq 0x5ca9f(%rip), %r13     # 0x152380
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 0xf58e1
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_O3/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 0xf597c
movq 0x8(%rcx), %rax
cmpq %rsi, %rax
je 0xf5a15
cmpb $0x1, (%rax)
jne 0xf5976
cmpq %rsi, 0x8(%rax)
je 0xf5a15
movq 0x10(%rcx), %rcx
jmp 0xf5955
movq 0xd0(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax,%rbx,8), %r15
cmpb $0x1, (%r15)
jne 0xf59a7
movq %r15, %rax
movq 0x8(%rax), %rcx
cmpq %rsi, 0x8(%rcx)
je 0xf5a15
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xf5994
cmpb $0x1c, (%rdx)
jne 0xf5a15
movq 0x8(%rdx), %r12
testq %r12, %r12
je 0xf59c3
cmpq %rsi, 0x8(%r12)
je 0xf59c9
movq 0x18(%r12), %r12
jmp 0xf59b0
movq 0x10(%rdx), %rdx
jmp 0xf59a7
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0xf59e8
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %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_O3/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 0xf5a7b
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xf5a88
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0xf5a96
movq 0x10(%rcx), %rsi
cmpb $0x1, (%rsi)
jne 0xf5aab
movq 0x10(%rax), %rax
addq $-0x4, %r14
cmpq %rax, %rsi
jne 0xf5a3e
movq 0x5842a(%rip), %rax     # 0x14dea0
jmp 0xf5b11
movl $0x1, %eax
subq %r14, %rax
decq %r14
jmp 0xf5aa2
movl $0x2, %eax
subq %r14, %rax
addq $-0x2, %r14
jmp 0xf5aa2
movl $0x3, %eax
subq %r14, %rax
addq $-0x3, %r14
cmpq 0x110(%rbx), %rcx
jmp 0xf5abe
movl $0x4, %eax
subq %r14, %rax
addq $-0x4, %r14
cmpq 0x110(%rbx), %rsi
cmoveq %rax, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xf5ad8
leaq 0x50e7e(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xf5b11
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xf5af7
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0xf5f4b
movq %rsi, %r14
movl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0xf5f5e
cmpl $0x1, %ecx
jne 0xf5f4b
movq 0x18(%r14), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xf5fc3
leaq 0x50a0b(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xf5f52
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
xorl %esi, %esi
movl $0x2, %edx
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 0xf6001
leaq 0x50993(%rip), %rax     # 0x146950
movq (%rax,%r15,8), %rax
jmp 0xf5f52
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xf5fe2
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xf5f52
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xf6020
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
jmp 0xf5f52
// File: /workspace/github_c_makefile_star2_O3/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 0xf6070
cmpl $0x1, 0x4(%rax)
jne 0xf6070
movq 0x20(%rsi), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0xf607f
leaq 0x508e6(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0xf6077
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xf609e
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0xf6077
// File: /workspace/github_c_makefile_star2_O3/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 0xf6532
cmpb $0x24, (%rdx)
jne 0xf652f
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
jne 0xf652f
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_O3/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 0xf6638
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movb (%rsi), %al
cmpb (%rdx), %al
jne 0xf662c
testb $0x40, 0x3(%r14)
je 0xf662c
movq %rdi, %rbx
cmpb $0x1, 0x24c(%rdi)
jne 0xf662c
testb $0x40, 0x3(%r15)
je 0xf662c
movq 0x18(%r14), %rsi
movq 0x1070(%rbx), %rdx
movq %rbx, %rdi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0xf662c
movq %rax, %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xf65d5
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %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 0xaee6
cmpq %rax, 0x120(%rbx)
setne %al
jmp 0xf662e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf6db6
movq 0x8(%rsi), %rax
cmpq 0x8(%rdx), %rax
jne 0xf6db6
movq 0x10(%rsi), %rax
cmpq 0x10(%rdx), %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf6dd2
movsd 0x8(%rdx), %xmm0
cmpeqsd 0x8(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: complex_equal
static bool complex_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_complex(y)) &&
                            (real_part(x) == real_part(y)) &&
                            (imag_part(x) == imag_part(y)));
                }

// Assembly:
cmpb $0xe, (%rdx)
jne 0xf6dfc
movsd 0x8(%rsi), %xmm0
ucomisd 0x8(%rdx), %xmm0
jne 0xf6dfc
jp 0xf6dfc
movsd 0x10(%rdx), %xmm0
cmpeqsd 0x10(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: symbol_equivalent
static bool symbol_equivalent(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci)
                {
                    if (x == y) return(true);
                    if (!is_normal_symbol(y)) return(false);            /* (equivalent? ''(1) '(1)) */
                    return((is_slot(global_slot(x))) &&                 /* the optimizer can replace the original symbol with its own */
                            (is_syntax(slot_value(global_slot(x)))) &&
                            (is_slot(global_slot(y))) &&
                            (is_syntax(slot_value(global_slot(y)))) &&
                            (syntax_symbol(slot_value(global_slot(x))) == syntax_symbol(slot_value(global_slot(y)))));
                }

// Assembly:
cmpq %rdx, %rsi
je 0xf6e42
cmpb $0xa, (%rdx)
jne 0xf6e3f
testb $-0x80, 0x6(%rdx)
jne 0xf6e3f
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
jne 0xf6e3f
movq 0x10(%rax), %rax
cmpb $0x9, (%rax)
jne 0xf6e3f
movq 0x10(%rdx), %rcx
cmpb $0x20, (%rcx)
jne 0xf6e3f
movq 0x10(%rcx), %rcx
cmpb $0x9, (%rcx)
jne 0xf6e3f
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
sete %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: port_equivalent
static bool port_equivalent(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 ((port_is_closed(x)) && (port_is_closed(y))) return(true);
                    if ((port_is_closed(x)) || (port_is_closed(y))) return(false); /* if either is closed, port_port (below) might be null */
                    if (port_type(x) != port_type(y)) return(false);
                    switch (port_type(x))
                    {
                        case STRING_PORT:
                            return((port_position(x) == port_position(y)) &&
                                    (port_data_size(x) == port_data_size(y)) &&
                                    (local_strncmp((const char *)port_data(x), (const char *)port_data(y), (is_input_port(x)) ? port_data_size(x) : port_position(x))));
                        case FILE_PORT:
                            return((is_input_port(x)) &&
                                    (port_position(x) == port_position(y)) &&
                                    (local_strncmp((const char *)port_filename(x), (const char *)port_filename(y), port_filename_length(x))));
                        case FUNCTION_PORT:
                            if (is_input_port(x))
                                return(port_input_function(x) == port_input_function(y));
                            return(port_output_function(x) == port_output_function(y));
                    }
                    return(false);
                }

// Assembly:
cmpq %rdx, %rsi
je 0xf713e
movb (%rsi), %cl
cmpb (%rdx), %cl
jne 0xf71b2
movq 0x8(%rsi), %r8
movb 0x2(%r8), %al
movq 0x8(%rdx), %rdi
movb 0x2(%rdi), %r9b
movl %eax, %r10d
orb %r9b, %r10b
testb $0x1, %r10b
je 0xf7141
andb %r9b, %al
retq
movb $0x1, %al
retq
movl 0x4(%r8), %eax
cmpl 0x4(%rdi), %eax
jne 0xf71b2
testl %eax, %eax
je 0xf7192
cmpl $0x2, %eax
je 0xf7183
cmpl $0x1, %eax
jne 0xf71b2
movq 0x20(%rsi), %rax
cmpq 0x20(%rdx), %rax
jne 0xf71b2
movq 0x18(%rsi), %r8
cmpq 0x18(%rdx), %r8
jne 0xf71b2
movq 0x10(%rsi), %rdi
cmpb $0x23, %cl
cmoveq %r8, %rax
movq 0x10(%rdx), %rsi
movq %rax, %rdx
jmp 0x8c146
cmpb $0x23, %cl
jne 0xf71b5
movq 0x50(%r8), %rax
cmpq 0x50(%rdi), %rax
jmp 0xf71bd
cmpb $0x23, %cl
jne 0xf71b2
movq 0x20(%rsi), %rax
cmpq 0x20(%rdx), %rax
jne 0xf71b2
movq 0x10(%rdi), %rsi
movq 0x10(%r8), %rdi
movq 0x30(%r8), %rdx
jmp 0x8c146
xorl %eax, %eax
retq
movq 0x58(%r8), %rax
cmpq 0x58(%rdi), %rax
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: closure_equivalent
static bool closure_equivalent(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, y))
                        check_equivalent_method(sc, x, y);
                    /* not sure about this -- we can't simply check let_equal(closure_let(x), closure_let(y))
                     *   because locally defined constant functions on the second pass find the outer let.
                     */
                    return((s7_is_equivalent_1(sc, closure_args(x), closure_args(y), ci)) &&
                            (s7_is_equivalent_1(sc, closure_body(x), closure_body(y), ci)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
je 0xf72b6
movq %rdx, %r15
movq %rsi, %r14
movb (%rsi), %al
cmpb (%rdx), %al
jne 0xf72fc
movq %rcx, %r12
movq %rdi, %rbx
testb $0x40, 0x3(%r15)
je 0xf72ba
cmpb $0x1, 0x24c(%rbx)
jne 0xf72ba
testb $0x40, 0x3(%r14)
je 0xf72ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a63
movq 0x1100(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0xf72ba
movq %rax, %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xf725f
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 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 %r13, %rsi
callq 0xaee6
cmpq %rax, 0x120(%rbx)
setne %al
jmp 0xf72fe
movb $0x1, %al
jmp 0xf72fe
movq 0x8(%r14), %rsi
movq 0x8(%r15), %rdx
movzbl (%rsi), %eax
leaq 0x5bbf4(%rip), %r13     # 0x152ec0
movq %rbx, %rdi
movq %r12, %rcx
callq *(%r13,%rax,8)
testb %al, %al
je 0xf72fc
movq 0x10(%r14), %rsi
movq 0x10(%r15), %rdx
movzbl (%rsi), %eax
movq (%r13,%rax,8), %rax
movq %rbx, %rdi
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq