LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_byte_multivector
static s7_pointer g_byte_multivector(s7_scheme *sc, s7_int dims, s7_pointer data)
                {
                    /* dims > 1, sc->value is a pair (not null) */
                    s7_pointer *src;
                    s7_int i, len;
                    sc->value = g_multivector(sc, dims, data);
                    src = (s7_pointer *)vector_elements(sc->value);
                    len = vector_length(sc->value);
                    for (i = 0; i < len; i++)
                        if (!is_byte(src[i]))
                            return(s7_wrong_type_arg_error(sc, "#u(...)", i + 1, src[i], "a byte"));
                    sc->args = g_make_vector_1(sc, set_plist_2(sc, g_vector_dimensions(sc, set_plist_1(sc, sc->value)), small_int(0)), sc->make_byte_vector_symbol);
                    return(s7_copy_1(sc, sc->byte_vector_symbol, set_plist_2(sc, sc->value, sc->args)));
                }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x19a120
movq %rax, %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x58(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
jge 0x19ad0e
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xd8510
testb $0x1, %al
jne 0x19acfc
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rdx
addq $0x1, %rdx
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x56b2e(%rip), %rsi     # 0x1f1814
leaq 0x53e9a(%rip), %r8      # 0x1eeb87
callq 0x12540
movq %rax, 0x60(%rsp)
jmp 0x19add3
jmp 0x19acfe
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x19aca0
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x35ea0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x359e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x7b725(%rip), %rdx     # 0x216480
callq 0x36f70
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x58(%rsp), %rax
movq 0x12d0(%rax), %rdx
callq 0x35ed0
movq %rax, %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq 0xc28(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x36f70
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0x3e9e0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rax
cmpq $0x2c, 0x18(%rax)
jl 0x19b0af
movq 0x40(%rsp), %rdi
callq 0xcfdf0
movq %rax, 0x50(%rsp)
jmp 0x19b1e2
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rcx
leaq 0x7ac1c(%rip), %rax     # 0x215ce0
movq (%rax,%rcx,8), %rsi
callq 0xb400
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x19b1f0
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x19b14d
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x19b1e2
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x19b185
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: sl_c_types
static s7_pointer sl_c_types(s7_scheme *sc)
                {
                    s7_pointer res;
                    int32_t i;
                    sc->w = sc->nil;
                    for (i = 0; i < sc->num_c_object_types; i++)                       /*   c-object type (tag) is i */
                        sc->w = cons(sc, sc->c_object_types[i]->scheme_name, sc->w);
                    res = safe_reverse_in_place(sc, sc->w);                            /*   so car(types) has tag 0 */
                    sc->w = sc->nil;
                    return(res);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x8e4(%rcx), %eax
jge 0x19be25
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x19bdb1
movq 0x30(%rsp), %rdi
callq 0xc670
movq 0x30(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x19bd49
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x4d8(%rax), %rsi
callq 0xe460
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: sl_file_names
static s7_pointer sl_file_names(s7_scheme *sc)
                {
                    int32_t i;
                    s7_pointer p;
                    sc->w = sc->nil;
                    for (i = 0; i <= sc->file_names_top; i++)
                        sc->w = cons(sc, sc->file_names[i], sc->w);
                    p = sc->w;
                    sc->w = sc->nil;
                    return(p);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x4a4(%rcx), %eax
jg 0x19bf71
movq 0x30(%rsp), %rax
movq 0x498(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x19befd
movq 0x30(%rsp), %rdi
callq 0xc670
movq 0x30(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x19be99
movq 0x30(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xc3980
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xc3980
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xc39c0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xc3980
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
jne 0x1a0a18
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rsi
movq (%rsp), %rax
movq 0x20(%rax), %rax
subq %rax, %rsi
sarq $0x3, %rsi
callq 0xc3ae0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xc3980
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xc3980
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xc3980
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xc3980
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xc3980
movq (%rsp), %rax
movq (%rax), %rax
andq $0x4000000, %rax        # imm = 0x4000000
cmpq $0x0, %rax
je 0x1a0d96
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xc3980
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: display_any
static void display_any(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
#if S7_DEBUGGING
        print_debugging_state(sc, obj, port);
#else
        {
            char *str, *tmp;
            block_t *b;
            s7_int nlen, len;
            tmp = describe_type_bits(sc, obj);
            len = 32 + safe_strlen(tmp);
            b = mallocate(sc, len);
            str = (char *)block_data(b);
            if (is_free(obj))
                nlen = catstrs_direct(str, "<free cell! ", tmp, ">", NULL);
            else nlen = catstrs_direct(str, "<unknown object! ", tmp, ">", NULL);
            port_write_string(port)(sc, str, nlen, port);
            free(tmp);
            liberate(sc, b);
        }
#endif
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x1abaf0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa430
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xaa80
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1a0eac
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x5105e(%rip), %rsi     # 0x1f1ef0
leaq 0x51bce(%rip), %rcx     # 0x1f2a67
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x10540
movq %rax, 0x10(%rsp)
jmp 0x1a0ed5
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x51040(%rip), %rsi     # 0x1f1efd
leaq 0x51ba3(%rip), %rcx     # 0x1f2a67
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x10540
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq *%rax
movq 0x20(%rsp), %rdi
callq 0x9050
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb230
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq %r8, (%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x1a8b20
cmpl $0x2, 0xc(%rsp)
jne 0x1a8b20
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rcx
leaq 0x49ce4(%rip), %rsi     # 0x1f27a3
movl $0x19, %edx
callq *%rax
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rsi
movq 0x18(%rsp), %rcx
movq 0x28(%rcx), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rcx
leaq 0x49ca6(%rip), %rsi     # 0x1f27bd
movl $0x7, %edx
callq *%rax
jmp 0x1a8b4f
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rsi
movq 0x18(%rsp), %rcx
movq 0x28(%rcx), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
andq $0x8000000, %rax        # imm = 0x8000000
cmpq $0x0, %rax
je 0x1a977c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x1a9741
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rsp), %rcx
movzbl 0x18(%rcx), %ecx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x1a9714
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rax
addq 0x20(%rax), %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
addq $0x10, %rsi
addq $0x1, %rsi
movq 0x28(%rsp), %rax
movzbl 0x18(%rax), %eax
movl %eax, %edx
callq 0x93e0
movq 0x28(%rsp), %rax
movzbl 0x18(%rax), %eax
movl %eax, %ecx
movq 0x20(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x1a973f
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
addq $0x10, %rsi
addq $0x1, %rsi
movq 0x28(%rsp), %rax
movzbl 0x18(%rax), %eax
movl %eax, %edx
movq 0x20(%rsp), %rcx
callq 0xcf5e0
jmp 0x1a977a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
addq $0x10, %rsi
addq $0x1, %rsi
movq 0x28(%rsp), %rcx
movzbl 0x18(%rcx), %ecx
movl %ecx, %edx
movq 0x20(%rsp), %rcx
callq *%rax
jmp 0x1a97d3
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdx
callq 0xc7240
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
movl %eax, %edx
callq 0x1b0180
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq *%rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
andq $0x8000000, %rax        # imm = 0x8000000
cmpq $0x0, %rax
je 0x1a984e
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x8, %rsi
addq $0x10, %rsi
addq $0x1, %rsi
movq 0x38(%rsp), %rcx
movzbl 0x18(%rcx), %ecx
movl %ecx, %edx
movq 0x30(%rsp), %rcx
callq *%rax
jmp 0x1a9964
movq $0x0, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rax
movslq 0x468(%rax), %rcx
movl 0x2c(%rsp), %eax
xorl %edx, %edx
movl $0x67, %r8d
leaq 0x18(%rsp), %r9
movl %eax, (%rsp)
callq 0xc66e0
movq %rax, 0x10(%rsp)
cmpq $0x16, 0x18(%rsp)
jge 0x1a993d
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
je 0x1a993d
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x69, %eax
je 0x1a993d
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xe, %eax
jne 0x1a9927
movq 0x38(%rsp), %rax
movsd 0x10(%rax), %xmm0
callq 0x13860
testb $0x1, %al
jne 0x1a993d
movq 0x38(%rsp), %rax
movsd 0x10(%rax), %xmm1
movaps %xmm1, %xmm0
movaps 0x381b3(%rip), %xmm2    # 0x1e1aa0
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x38061(%rip), %xmm1    # 0x1e1970
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
jne 0x1a993d
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movl %eax, %edx
callq 0x1b0180
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq *%rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
cmpl $0x2, 0x1c(%rsp)
jne 0x1aa372
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0xb400
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x1aa370
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x10000, %rax          # imm = 0x10000
cmpq $0x0, %rax
jne 0x1aa370
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x4874e(%rip), %rsi     # 0x1f2a7f
movl $0x2, %edx
callq *%rax
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rsi
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rcx), %rdx
movq 0x20(%rsp), %rcx
callq *%rax
jmp 0x1aa3e2
jmp 0x1aa372
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1aa3b9
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rsi
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rcx), %rdx
movq 0x20(%rsp), %rcx
callq *%rax
jmp 0x1aa3e2
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x486a7(%rip), %rsi     # 0x1f2a82
movl $0x15, %edx
callq *%rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: rng_to_port
static void rng_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        int32_t nlen;
        char buf[128];
#if WITH_GMP
        if (use_write == P_READABLE)
            nlen = snprintf(buf, 128, "#<unprint-readable object>");
        else nlen = snprintf(buf, 128, "#<rng %p>", obj);
#else
        if (use_write == P_READABLE)
            nlen = snprintf(buf, 128, "(random-state %" PRIu64 " %" PRIu64 ")", random_seed(obj), random_carry(obj));
        else nlen = snprintf(buf, 128, "#<rng %" PRIu64 " %" PRIu64 ">", random_seed(obj), random_carry(obj));
#endif
        port_write_string(port)(sc, buf, nlen, port);
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movq %r8, 0x90(%rsp)
cmpl $0x2, 0x9c(%rsp)
jne 0x1aaccf
movq %rsp, %rdi
movq 0xa8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %r8
movl $0x80, %esi
leaq 0x47e21(%rip), %rdx     # 0x1f2ae0
movb $0x0, %al
callq 0x9210
movl %eax, 0x8c(%rsp)
jmp 0x1aad04
movq %rsp, %rdi
movq 0xa8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %r8
movl $0x80, %esi
leaq 0x47e01(%rip), %rdx     # 0x1f2af7
movb $0x0, %al
callq 0x9210
movl %eax, 0x8c(%rsp)
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rsp), %rdi
movq %rsp, %rsi
movslq 0x8c(%rsp), %rdx
movq 0xa0(%rsp), %rcx
callq *%rax
addq $0xb8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
cqto
idivq 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
jle 0x1ae6b4
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
subq 0x10(%rsp), %rax
cqto
idivq 0x18(%rsp)
movq %rax, %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movl 0x24(%rsp), %r8d
subl $0x1, %r8d
callq 0x1ae630
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xae30
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl $0x80, %esi
leaq 0x43dfb(%rip), %rdx     # 0x1f24dc
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xabd0
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
addq $0xb70, %rax            # imm = 0xB70
addq $0x20, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rsp)
movb $0x0, (%rax)
movq -0x10(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
leaq 0x3f8c9(%rip), %rax     # 0x1ee015
movb (%rax,%rdx), %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x1ae736
movq -0x18(%rsp), %rax
addq $0x1, %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rsp), %rdi
movq 0xa0(%rsp), %rcx
leaq 0x43cbf(%rip), %rsi     # 0x1f2499
movl $0x3, %edx
callq *%rax
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0xa8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x1ae8a5
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xc70d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
leaq 0x43c8a(%rip), %rdx     # 0x1f24dc
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x10540
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0xa0(%rsp), %rcx
callq *%rax
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1ae7ea
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0xb0(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xc70d0
movq (%rsp), %rdi
movq %rax, %rsi
leaq 0x43ceb(%rip), %rdx     # 0x1f25d0
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x10540
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0xb0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0xa0(%rsp), %rcx
callq *%rax
addq $0xb8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0x1aee4d
movq 0x761d2(%rip), %rax     # 0x224ff8
movq -0x20(%rsp), %rcx
movzbl (%rcx), %ecx
testb $0x1, (%rax,%rcx)
je 0x1aee3b
movb $0x1, -0x1(%rsp)
jmp 0x1aee52
jmp 0x1aee3d
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x1aee13
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: let_has_setter
static bool let_has_setter(s7_scheme *sc, s7_pointer obj)
    {
        s7_pointer slot;
        for (slot = let_slots(obj); tis_slot(slot); slot = next_slot(slot))
            if (slot_has_setter(slot))
                return(true);
        return(false);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x1af3ed
movq -0x20(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x1af3db
movb $0x1, -0x1(%rsp)
jmp 0x1af3f2
jmp 0x1af3dd
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x1af3b8
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1afc81
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x1afc6c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x42c37(%rip), %rsi     # 0x1f2793
movl $0xf, %edx
callq *%rax
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %r8
xorl %ecx, %ecx
callq 0x1a9970
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x42b37(%rip), %rsi     # 0x1f26db
movl $0x2, %edx
callq *%rax
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1afc18
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x722be(%rip), %rax     # 0x221e90
testb $0x1, (%rax,%rcx)
je 0x1afc18
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x15, %eax
jne 0x1afbf8
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x1afc18
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %r8
movl $0x2, %ecx
callq 0xd0220
jmp 0x1afc48
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x722a7(%rip), %rax     # 0x221ed0
movq (%rax,%rcx,8), %rax
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %r8
movl $0x2, %ecx
callq *%rax
jmp 0x1afc4a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x29, %esi
callq *%rax
jmp 0x1afc6e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1afb16
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: funclet_slots_to_port
static void funclet_slots_to_port(s7_scheme *sc, s7_pointer obj, s7_pointer port, use_write_t use_write, shared_info *ci)
    {
        int32_t i;
        s7_pointer slot;
        for (i = 0, slot = let_slots(obj); tis_slot(slot); i++, slot = next_slot(slot))
        {
            port_write_character(port)(sc, ' ', port);
            object_to_port_with_circle_check(sc, slot, port, use_write, ci);
            if (i == (sc->print_length + 1))
            {
                port_write_string(port)(sc, " ...", 4, port);
                break;
            }
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1affee
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
movl $0x20, %esi
callq *%rax
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1aff58
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x71f7d(%rip), %rax     # 0x221e90
testb $0x1, (%rax,%rcx)
je 0x1aff58
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x15, %eax
jne 0x1aff39
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x1aff58
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %r8
callq 0xd0220
jmp 0x1aff87
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x71f67(%rip), %rax     # 0x221ed0
movq (%rax,%rcx,8), %rax
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %r8
callq *%rax
jmp 0x1aff89
movslq 0x1c(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x280(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x1affce
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rcx
leaq 0x3e69c(%rip), %rsi     # 0x1ee661
movl $0x4, %edx
callq *%rax
jmp 0x1affee
jmp 0x1affd0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1afec2
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1b016b
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %r8
movl 0xc(%rsp), %r9d
callq 0x1b0000
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x280(%rcx), %rax
jg 0x1b0124
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x20, %esi
callq *%rax
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1b00f3
movq (%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x71ddf(%rip), %rax     # 0x221e90
testb $0x1, (%rax,%rcx)
je 0x1b00f3
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x15, %eax
jne 0x1b00d5
movq (%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x1b00f3
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %r8
callq 0xd0220
jmp 0x1b0120
movq (%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x71dcd(%rip), %rax     # 0x221ed0
movq (%rax,%rcx,8), %rax
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %r8
callq *%rax
jmp 0x1b0122
jmp 0x1b0169
movslq 0xc(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x280(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x1b0167
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
leaq 0x3e501(%rip), %rsi     # 0x1ee661
movl $0x4, %edx
callq *%rax
jmp 0x1b0169
jmp 0x1b016b
movl 0xc(%rsp), %eax
addl $0x1, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpl $0x15, 0x4(%rsp)
jge 0x1b01fc
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x4000000, %rax        # imm = 0x4000000
cmpq $0x0, %rax
jne 0x1b01fc
movq 0x10(%rsp), %rax
movq (%rax), %rcx
orq $0x8000000, %rcx        # imm = 0x8000000
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x18(%rax)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
addq $0x1, %rdi
movq 0x8(%rsp), %rsi
movslq 0x4(%rsp), %rdx
callq 0x93e0
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, 0x19(%rax,%rcx)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: symbol_needs_slashification
static bool symbol_needs_slashification(s7_scheme *sc, s7_pointer obj)
    {
        uint8_t *p, *pend;
        const char *str;
        s7_int len;

        str = symbol_name(obj);
        if ((str[0] == '#') || (str[0] == '\'') || (str[0] == ','))
            return(true);

        if (s7_is_number(make_atom(sc, (char *)str, 10, NO_SYMBOLS, WITHOUT_OVERFLOW_ERROR)))
            return(true);

        len = symbol_name_length(obj);
        pend = (uint8_t *)(str + len);
        for (p = (uint8_t *)str; p < pend; p++)
            if (symbol_slashify_table[*p])
                return(true);

        set_clean_symbol(obj);
        return(false);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x1b0257
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x1b0257
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x1b0261
movb $0x1, 0x37(%rsp)
jmp 0x1b030a
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0xa, %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0xca470
movq %rax, %rdi
callq 0x11320
testb $0x1, %al
jne 0x1b0289
jmp 0x1b0290
movb $0x1, 0x37(%rsp)
jmp 0x1b030a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x1b02f3
movq 0x74d34(%rip), %rax     # 0x225000
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
testb $0x1, (%rax,%rcx)
je 0x1b02e1
movb $0x1, 0x37(%rsp)
jmp 0x1b030a
jmp 0x1b02e3
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1b02b9
movq 0x20(%rsp), %rax
movq (%rax), %rcx
orq $0x800000, %rcx         # imm = 0x800000
movq %rcx, (%rax)
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1b10dd
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x1b1070
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x1b1070
jmp 0x1b1109
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1b1107
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x1b14b0
jmp 0x1b1109
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: collect_specials
static void collect_specials(s7_scheme *sc, s7_pointer e, s7_pointer args, s7_int gc_loc)
    {
        collect_symbol(sc, sc->local_signature_symbol, e, args, gc_loc);
        collect_symbol(sc, sc->local_setter_symbol, e, args, gc_loc);
        collect_symbol(sc, sc->local_documentation_symbol, e, args, gc_loc);
        collect_symbol(sc, sc->local_iterator_symbol, e, args, gc_loc);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x16c8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x1b14b0
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x16d0(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x1b14b0
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x16c0(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x1b14b0
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x16d8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x1b14b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1b1600
testb $0x1, %al
jne 0x1b15f5
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1b1680
testb $0x1, %al
jne 0x1b15f5
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x1b16e0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1b15f3
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x50(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1b1580
movq 0x50(%rsp), %rdi
callq 0xc670
movq 0x50(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdx
movq 0x50(%rsp), %rax
movq 0xd0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1b15f5
addq $0x58, %rsp
retq
nopw (%rax,%rax)