LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_make_c_object_with_let
s7_pointer s7_make_c_object_with_let(s7_scheme *sc, s7_int type, void *value, s7_pointer let)
                {
                    s7_pointer x;
                    new_cell(sc, x, sc->c_object_types[type]->outer_type);

                    /* c_object_info(x) = &(sc->c_object_types[type]); */
                    /* that won't work because c_object_types can move when it is realloc'd and the old stuff is freed by realloc
                     *   and since we're checking (for example) ref_2 existence as not null, we can't use a table of c_object_t's!
                     */
                    c_object_type(x) = type;
                    c_object_value(x) = value;
                    c_object_set_let(x, (let == sc->rootlet) ? sc->nil : let);
                    c_object_mark(x) = sc->c_object_types[type]->mark;
                    add_c_object(sc, x);
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x3f22a
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq 0x8d8(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movq %r13, 0x10(%rbx)
cmpq %r12, 0x150(%r14)
jne 0x3f263
movq 0x110(%r14), %r12
movq %r12, 0x18(%rbx)
movq 0x8d8(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rbx)
movq 0x768(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x3f2a9
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %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: s7_c_object_set_let
s7_pointer s7_c_object_set_let(s7_scheme *sc, s7_pointer obj, s7_pointer e)
                {
                    if ((!is_immutable(obj)) &&
                            (is_let(e)))
                        c_object_set_let(obj, (e == sc->rootlet) ? sc->nil : e);
                    return(e);
                }

// Assembly:
movq %rdx, %rax
testb $0x1, 0x3(%rsi)
jne 0x3f2f8
cmpb $0x1c, (%rax)
jne 0x3f2f8
movq %rax, %rcx
cmpq %rax, 0x150(%rdi)
jne 0x3f2f4
movq 0x110(%rdi), %rcx
movq %rcx, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_dilambda
s7_pointer s7_dilambda(s7_scheme *sc,
                        const char *name,
                        s7_pointer (*getter)(s7_scheme *sc, s7_pointer args),
                        s7_int get_req_args, s7_int get_opt_args,
                        s7_pointer (*setter)(s7_scheme *sc, s7_pointer args),
                        s7_int set_req_args, s7_int set_opt_args,
                        const char *documentation)
                {
                    s7_pointer get_func, set_func;
                    char *internal_set_name;
                    s7_int len;

                    if (!name) return(sc->F);
                    len = 16 + safe_strlen(name);
                    internal_set_name = (char *)malloc(len);
                    internal_set_name[0] = '\0';
                    catstrs_direct(internal_set_name, "[set-", name, "]", NULL);

                    get_func = s7_make_safe_function(sc, name, getter, get_req_args, get_opt_args, false, documentation);
                    s7_define(sc, sc->nil, make_symbol(sc, name), get_func);
                    set_func = s7_make_function(sc, internal_set_name, setter, set_req_args, set_opt_args, false, documentation);
                    c_function_set_setter(get_func, set_func);

                    return(get_func);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x3f33b
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
cmpb $0x0, (%rsi)
movq %r9, 0x10(%rsp)
je 0x3f347
movl $0x10, %eax
leaq 0x1(%rax), %rdi
cmpb $0x0, -0xf(%r13,%rax)
movq %rdi, %rax
jne 0x3f32a
jmp 0x3f34c
movq 0x120(%r14), %r15
jmp 0x3f3ed
movl $0x10, %edi
callq 0x8480
movq %rax, %rbx
movb $0x0, (%rax)
leaq 0xcaf95(%rip), %rsi     # 0x10a2f3
leaq 0xcaffa(%rip), %rcx     # 0x10a35f
movq %rax, %rdi
movq %r13, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xc442
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0x3ddd8
movq %rax, %r15
orb $0x20, 0x2(%rax)
movq 0x110(%r14), %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x9afc
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbfdc
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %r8
xorl %r9d, %r9d
callq 0x3ddd8
movq 0x8(%r15), %rcx
movq %rax, 0x30(%rcx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_typed_dilambda
s7_pointer s7_typed_dilambda(s7_scheme *sc,
                        const char *name,
                        s7_pointer (*getter)(s7_scheme *sc, s7_pointer args),
                        s7_int get_req_args, s7_int get_opt_args,
                        s7_pointer (*setter)(s7_scheme *sc, s7_pointer args),
                        s7_int set_req_args, s7_int set_opt_args,
                        const char *documentation,
                        s7_pointer get_sig, s7_pointer set_sig)
                {
                    s7_pointer get_func, set_func;
                    get_func = s7_dilambda(sc, name, getter, get_req_args, get_opt_args, setter, set_req_args, set_opt_args, documentation);
                    set_func = c_function_setter(get_func);
                    if (get_sig) c_function_signature(get_func) = get_sig;
                    if (set_sig) c_function_signature(set_func) = set_sig;
                    return(get_func);
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r14
movaps 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x3f2f9
movq 0x8(%rax), %rcx
testq %r14, %r14
je 0x3f435
movq %r14, 0x38(%rcx)
testq %rbx, %rbx
je 0x3f446
movq 0x30(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, 0x38(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: numbers_are_eqv
static bool numbers_are_eqv(s7_pointer a, s7_pointer b)
                {
                    if (type(a) != type(b)) /* (eqv? 1 1.0) -> #f! */
                        return(false);

                    switch (type(a))
                    {
                        case T_INTEGER:
                            return((integer(a) == integer(b)));

                        case T_RATIO:
                            return((numerator(a) == numerator(b)) &&
                                    (denominator(a) == denominator(b)));

                        case T_REAL:
                            if (is_NaN(real(a)))
                                return(false);
                            return(real(a) == real(b));

                        case T_COMPLEX:
                            if ((is_NaN(real_part(a))) ||
                                    (is_NaN(imag_part(a))))
                                return(false);
                            return((real_part(a) == real_part(b)) &&
                                    (imag_part(a) == imag_part(b)));

                        default:
#if WITH_GMP
                            if ((is_big_number(a)) || (is_big_number(b))) /* this can happen if (member bignum ...) -> memv */
                                return(big_numbers_are_eqv(a, b));
#endif
                            break;
                    }
                    return(false);
                }

// Assembly:
movzbl (%rdi), %eax
cmpb (%rsi), %al
jne 0x404be
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x404be
leaq 0xc7230(%rip), %rcx     # 0x107684
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x404ba
movsd 0x8(%rdi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x404be
cmpeqsd 0x8(%rsi), %xmm0
jmp 0x4049f
movsd 0x8(%rdi), %xmm1
ucomisd %xmm1, %xmm1
jp 0x404be
movsd 0x10(%rdi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x404be
ucomisd 0x8(%rsi), %xmm1
jne 0x404be
jp 0x404be
cmpeqsd 0x10(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x404be
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_fill_1
static s7_pointer g_string_fill_1(s7_scheme *sc, s7_pointer caller, s7_pointer args)
    {
        s7_pointer x, chr;
        s7_int start = 0, end;
        x = car(args);

        if (!is_string(x))
            return(method_or_bust(sc, x, caller, args, T_STRING, 1)); /* not two methods here */
        if (is_immutable_string(x))
            return(immutable_object_error(sc, set_elist_3(sc, immutable_error_string, caller, x)));

        chr = cadr(args);
        if (!s7_is_character(chr))
            return(method_or_bust(sc, chr, caller, args, T_CHARACTER, 2));

        end = string_length(x);
        if (!is_null(cddr(args)))
        {
            s7_pointer p;
            p = start_and_end(sc, caller, args, 3, &start, &end);
            if (p != sc->unused)
                return(p);
            if (start == end) return(chr);
        }
        if (end == 0) return(chr);

        if ((int)(character(chr)) == 0)
            memclr((void *)(string_value(x) + start), end - start);
        else local_memset((void *)(string_value(x) + start), (int32_t)character(chr), end - start);

        return(chr);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r15
movq $0x0, 0x10(%rsp)
movq 0x8(%rcx), %r12
cmpb $0x13, (%r12)
jne 0x427e4
testb $0x1, 0x3(%r12)
jne 0x42806
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rbx
cmpb $0x8, (%rbx)
jne 0x42846
movq 0x8(%r12), %r14
movq %r14, 0x8(%rsp)
movq 0x10(%rax), %rax
cmpq 0x110(%r15), %rax
je 0x4285a
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movl $0x3, %ecx
callq 0x9a55e
movq %rax, %r14
cmpq 0x140(%r15), %rax
jne 0x428de
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r14
cmpq %r14, %r15
jne 0x4285d
jmp 0x428db
movq %r15, %rdi
movq %r12, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe42d
movq 0x10815b(%rip), %rax    # 0x14a968
movq 0x6e8(%r15), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r12, 0x8(%rax)
movq 0x6e8(%r15), %rdx
movq 0xea8(%r15), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x38dfa
jmp 0x428de
movq %r15, %rdi
movq %rbx, %rsi
movl $0x8, %r8d
movl $0x2, %r9d
jmp 0x427f6
xorl %r15d, %r15d
testq %r14, %r14
je 0x428db
movzbl 0x8(%rbx), %esi
subq %r15, %r14
addq 0x10(%r12), %r15
testq %rsi, %rsi
je 0x428a8
cmpq $0x8, %r14
jb 0x4289e
movq %r14, %rax
shrq $0x3, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rsi, %rcx
movq %rcx, (%r15)
addq $0x8, %r15
decq %rax
jne 0x4288e
andl $0x7, %r14d
testq %r14, %r14
je 0x428db
movq %r15, %rdi
jmp 0x428d3
cmpq $0x8, %r14
jb 0x428c9
movq %r14, %r12
andq $-0x8, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x8270
addq %r12, %r15
andl $0x7, %r14d
testq %r14, %r14
je 0x428db
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8270
movq %rbx, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: copy_list
static inline s7_pointer copy_list(s7_scheme *sc, s7_pointer lst)
                {
                    s7_pointer p, tp, np;
                    if (!is_pair(lst)) return(sc->nil);
                    sc->u = lst;
                    tp = cons(sc, car(lst), sc->nil);
                    sc->y = tp;
                    for (p = cdr(lst), np = tp; is_pair(p); p = cdr(p), np = cdr(np))
                        set_cdr(np, cons(sc, car(p), sc->nil));
                    sc->y = sc->nil;
                    sc->u = sc->nil;
                    return(tp);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x43057
movq %rsi, %r15
movq %rsi, 0x4c8(%rbx)
movq 0x8(%rsi), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x42fb4
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200001, (%r14)       # imm = 0x200001
movq %r12, 0x8(%r14)
movq %r13, 0x10(%r14)
movq %r14, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x43040
movq %r14, %r12
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x43010
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 %r13, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq %rax, 0x10(%r12)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r12
je 0x42fe6
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
jmp 0x4305e
movq 0x110(%rbx), %r14
movq %r14, %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: type_name_string
static s7_pointer type_name_string(s7_scheme *sc, s7_pointer arg)
                {
                    if (type(arg) < NUM_TYPES)
                    {
                        s7_pointer p;
                        p = prepackaged_type_names[type(arg)]; /* these use INDEFINITE_ARTICLE */
                        if (is_string(p)) return(p);
                    }
                    return(s7_make_string_wrapper(sc, type_name(sc, arg, INDEFINITE_ARTICLE)));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpq $0x33, %rax
ja 0x4374e
leaq 0x10731b(%rip), %rcx    # 0x14aa60
movq (%rcx,%rax,8), %rcx
cmpb $0x13, (%rcx)
je 0x4379e
movq %rbx, %rdi
movl $0x1, %edx
callq 0x9c349
testq %rax, %rax
je 0x43777
cmpb $0x0, (%rax)
je 0x43777
xorl %ecx, %ecx
leaq 0x1(%rcx), %rdx
cmpb $0x0, 0x1(%rax,%rcx)
movq %rdx, %rcx
jne 0x43767
jmp 0x43779
xorl %edx, %edx
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %rsi
movq (%rcx,%rsi,8), %rcx
incl %esi
andl $0x7, %esi
movl %esi, 0x7dc(%rbx)
movq %rax, 0x10(%rcx)
movq %rdx, 0x8(%rcx)
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_out_of_range_error
s7_pointer s7_out_of_range_error(s7_scheme *sc, const char *caller, s7_int arg_n, s7_pointer arg, const char *descr)
                {
                    if (arg_n > 0)
                        return(out_of_range_error_prepackaged(sc, wrap_string(sc, caller, safe_strlen(caller)), wrap_integer1(sc, arg_n), arg,
                                    wrap_string(sc, descr, safe_strlen(descr))));
                    return(simple_out_of_range_error_prepackaged(sc, wrap_string(sc, caller, safe_strlen(caller)),
                                arg, wrap_string(sc, descr, safe_strlen(descr))));
                }

// Assembly:
testq %rdx, %rdx
jle 0x43869
testq %rsi, %rsi
je 0x437ca
cmpb $0x0, (%rsi)
je 0x437ca
xorl %r9d, %r9d
leaq 0x1(%r9), %rax
cmpb $0x0, 0x1(%rsi,%r9)
movq %rax, %r9
jne 0x437b9
jmp 0x437cc
xorl %eax, %eax
movq 0x820(%rdi), %r9
movslq 0x7dc(%rdi), %r10
movq (%r9,%r10,8), %r9
incl %r10d
andl $0x7, %r10d
movl %r10d, 0x7dc(%rdi)
movq %rsi, 0x10(%r9)
movq %rax, 0x8(%r9)
movq 0x1f00(%rdi), %rax
movq %rdx, 0x8(%rax)
testq %r8, %r8
je 0x4381d
cmpb $0x0, (%r8)
je 0x4381d
xorl %eax, %eax
leaq 0x1(%rax), %rsi
cmpb $0x0, 0x1(%r8,%rax)
movq %rsi, %rax
jne 0x4380c
jmp 0x4381f
xorl %esi, %esi
movq 0x1f00(%rdi), %rax
movq 0x820(%rdi), %rdx
movslq 0x7dc(%rdi), %r10
movq (%rdx,%r10,8), %rdx
incl %r10d
andl $0x7, %r10d
movl %r10d, 0x7dc(%rdi)
movq %r8, 0x10(%rdx)
movq %rsi, 0x8(%rdx)
leaq 0x1ee8(%rdi), %r8
movq 0x1ee8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %r9, 0x8(%rsi)
jmp 0x43905
testq %rsi, %rsi
je 0x43885
cmpb $0x0, (%rsi)
je 0x43885
xorl %eax, %eax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%rsi,%rax)
movq %rdx, %rax
jne 0x43875
jmp 0x43887
xorl %edx, %edx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r9
movq (%rax,%r9,8), %rax
incl %r9d
andl $0x7, %r9d
movl %r9d, 0x7dc(%rdi)
movq %rsi, 0x10(%rax)
movq %rdx, 0x8(%rax)
testq %r8, %r8
je 0x438cd
cmpb $0x0, (%r8)
je 0x438cd
xorl %edx, %edx
leaq 0x1(%rdx), %rsi
cmpb $0x0, 0x1(%r8,%rdx)
movq %rsi, %rdx
jne 0x438bc
jmp 0x438cf
xorl %esi, %esi
movq 0x820(%rdi), %rdx
movslq 0x7dc(%rdi), %r9
movq (%rdx,%r9,8), %rdx
incl %r9d
andl $0x7, %r9d
movl %r9d, 0x7dc(%rdi)
movq %r8, 0x10(%rdx)
movq %rsi, 0x8(%rdx)
leaq 0x1ef8(%rdi), %r8
movq 0x1ef8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq (%r8), %rdx
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: fill_error_location
static void fill_error_location(s7_scheme *sc)
                {
                    if (in_reader(sc))
                    {
                        integer(slot_value(sc->error_line)) = port_line_number(sc->input_port);
                        slot_set_value(sc->error_file, wrap_string(sc, port_filename(sc->input_port), port_filename_length(sc->input_port)));
                    }
                    else
                    {
                        integer(slot_value(sc->error_line)) = 0;
                        slot_set_value(sc->error_file, sc->F);
                    }
                }

// Assembly:
movq $-0x1d1, %rax           # imm = 0xFE2F
addq 0x18(%rdi), %rax
cmpq $0xb, %rax
ja 0x43efb
movq 0x170(%rdi), %rax
cmpb $0x23, (%rax)
jne 0x43efb
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movq 0x1b8(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x170(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rax), %rdx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rsi
movq (%rax,%rsi,8), %rax
incl %esi
andl $0x7, %esi
movl %esi, 0x7dc(%rdi)
movq %rcx, 0x10(%rax)
movq %rdx, 0x8(%rax)
jmp 0x43f15
movq 0x1b8(%rdi), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq 0x120(%rdi), %rax
movq 0x1c0(%rdi), %rcx
movq %rax, 0x10(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: object_to_truncated_string
static s7_pointer object_to_truncated_string(s7_scheme *sc, s7_pointer p, s7_int len)
                {
                    char *s;
                    s7_int s_len;
                    s7_pointer strp;
                    sc->objstr_max_len = len + 2;
                    strp = s7_object_to_string(sc, p, false);
                    s = string_value(strp);
                    sc->objstr_max_len = s7_int_max;
                    s_len = string_length(strp);
                    if (s_len > len)
                        truncate_string(s, len, P_DISPLAY);
                    return(strp);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x2(%rdx), %rax
movq %rax, 0x288(%rdi)
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x37a4c
cmpb $0x0, 0x106cc0(%rip)    # 0x14ac08
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmoveq %r15, %rcx
movq 0x10(%rax), %rdx
movq %rcx, 0x288(%r14)
cmpq %rbx, 0x8(%rax)
jle 0x43fd2
leaq -0x4(%rbx), %rcx
movq %rbx, %rsi
shrq $0x3f, %rsi
addq %rbx, %rsi
sarq %rsi
cmpq %rsi, %rcx
jl 0x43fa1
movq 0x10e34c(%rip), %rdi    # 0x1522d0
addq %rdx, %rcx
leaq -0x3(%rbx), %r8
movzbl (%rcx), %r9d
cmpb $0x1, (%rdi,%r9)
je 0x43fc2
decq %rcx
decq %r8
cmpq %rsi, %r8
jg 0x43f8b
cmpq $0x4, %rbx
jl 0x43fba
leaq (%rdx,%rbx), %rcx
decq %rcx
movw $0x2e2e, -0x3(%rcx)     # imm = 0x2E2E
movb $0x2e, -0x1(%rcx)
jmp 0x43fcf
addq %rbx, %rdx
movq %rdx, %rcx
jmp 0x43fcf
movw $0x2e2e, (%rcx)         # imm = 0x2E2E
movb $0x2e, 0x2(%rcx)
addq $0x3, %rcx
movb $0x0, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_function_star
s7_pointer s7_apply_function_star(s7_scheme *sc, s7_pointer fnc, s7_pointer args)
                {
                    TRACK(sc);
                    set_current_code(sc, history_cons(sc, fnc, args));

                    if (is_c_function_star(fnc))
                    {
                        sc->w = sc->args;
                        sc->z = sc->code;
                        sc->args = T_Pos(args);
                        sc->code = fnc;
                        apply_c_function_star(sc);
                        sc->args = sc->w;
                        sc->code = sc->z;
                        return(sc->value);
                    }
                    push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                    sc->code = fnc;
                    sc->args = (needs_copied_args(sc->code)) ? copy_list(sc, args) : args;
                    eval(sc, OP_APPLY);
                    return(sc->value);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rdi)
cmpb $0x2f, (%rsi)
jne 0x44064
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
movq %rax, 0x4f0(%rbx)
movq %r14, 0x10(%rbx)
movq %rsi, (%rbx)
movq 0x10(%rsi), %r14
movq %rbx, %rdi
callq 0x441b1
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, 0x20(%rbx)
movq 0x4d8(%rbx), %rcx
movq 0x4f0(%rbx), %rdx
movq %rcx, 0x10(%rbx)
movq %rdx, (%rbx)
jmp 0x441a2
movq (%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1df, 0x18(%rax)      # imm = 0x1DF
addq $0x20, 0x50(%rbx)
movq %rsi, (%rbx)
testb $0x10, 0x3(%rsi)
jne 0x440a8
movq %r14, %r15
jmp 0x4418d
cmpb $0x1, (%r14)
jne 0x44186
movq %r14, 0x4c8(%rbx)
movq 0x8(%r14), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x440e3
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r12, 0x8(%r15)
movq %r13, 0x10(%r15)
movq %r15, 0x4e8(%rbx)
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0x4416f
movq %r15, %r12
movq 0x8(%r14), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x4413f
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 %r13, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq %rax, 0x10(%r12)
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
movq %rax, %r12
je 0x44115
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
jmp 0x4418d
movq 0x110(%rbx), %r15
movq %r15, 0x10(%rbx)
movl $0x198, %esi            # imm = 0x198
movq %rbx, %rdi
callq 0xfd85
movq 0x20(%rbx), %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: s7_quit
void s7_quit(s7_scheme *sc)
                {
                    sc->longjmp_ok = false;
                    pop_input_port(sc);
                    stack_reset(sc);
                    push_stack_op_let(sc, OP_EVAL_DONE);
                }

// Assembly:
movb $0x0, 0x678(%rdi)
movl 0x184(%rdi), %eax
testl %eax, %eax
je 0x44691
decl %eax
movl %eax, 0x184(%rdi)
shlq $0x3, %rax
addq 0x178(%rdi), %rax
jmp 0x44698
leaq 0x1c8(%rdi), %rax
movq (%rax), %rax
movq %rax, 0x170(%rdi)
movq 0x48(%rdi), %rax
movq %rax, 0x50(%rdi)
movl $0x1df, %ecx            # imm = 0x1DF
movq %rcx, 0x18(%rax)
movq 0x50(%rdi), %rax
leaq 0x20(%rax), %rdx
movq %rdx, 0x50(%rdi)
movq $0x203, 0x38(%rax)      # imm = 0x203
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rdx
leaq 0x20(%rdx), %rsi
movq %rsi, 0x50(%rdi)
movq %rax, 0x28(%rdx)
movq 0x50(%rdi), %rax
movq %rcx, 0x18(%rax)
addq $0x20, 0x50(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: d_ok
static void *opt_func(s7_pointer f, opt_func_t typ)
                {
                    if (is_c_function(f))
                    {
                        opt_funcs *p;
                        for (p = c_function_opt_data(f); p; p = p->next)
                            if (p->typ == typ)
                                return(p->func);
                    }
#if S7_DEBUGGING
                    else fprintf(stderr, "%s[%d]: 'f' is not a c_function\n", __func__, __LINE__);
#endif
                    return(NULL);
                }

// Assembly:
cmpb $0x30, (%rsi)
jb 0x9d339
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x9d339
cmpl $0xb, (%rax)
je 0x9d31f
movq 0x10(%rax), %rax
jmp 0x9d30f
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x9d339
leaq 0x1defc(%rip), %rcx     # 0xbb22b
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_float_optimize
s7_float_function s7_float_optimize(s7_scheme *sc, s7_pointer expr)
                {
#if WITH_GMP
                    return(NULL);
#endif
                    if (setjmp(sc->opt_exit) == 0)
                    {
                        sc->pc = 0;
                        reset_opts(sc);
                        if (float_optimize(sc, expr))
                            return(opt_float_any);
                    }
                    return(NULL);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x2190, %rdi           # imm = 0x2190
callq 0x8350
testl %eax, %eax
jne 0x44f57
movl $0x0, 0x2258(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44f61
testb %al, %al
je 0x44f57
leaq 0x921(%rip), %rax       # 0x45876
jmp 0x44f59
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_values
s7_pointer s7_values(s7_scheme *sc, s7_pointer args)
                {
#define H_values "(values obj ...) splices its arguments into whatever list holds it (its 'continuation')"
#define Q_values s7_make_circular_signature(sc, 1, 2, sc->values_symbol, sc->T)

                    if (is_null(args))         /* ((lambda () (let ((x 1)) (set! x (boolean? (values)))))) */
                        return(sc->no_value);
                    if (is_null(cdr(args)))
                        return(car(args));
                    set_needs_copied_args(args);
                    return(splice_in_values(sc, args));
                }

// Assembly:
movq 0x110(%rdi), %rax
cmpq %rsi, %rax
je 0x459d9
cmpq %rax, 0x10(%rsi)
je 0x459e1
orb $0x10, 0x3(%rsi)
jmp 0x35a2c
movq 0x138(%rdi), %rax
retq
movq 0x8(%rsi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_unique
static s7_pointer make_unique(s7_scheme *sc, const char* name, uint64_t typ)
                {
                    s7_pointer p;
                    p = alloc_pointer(sc);
                    set_type(p, typ | T_IMMUTABLE | T_UNHEAP);
                    unique_name_length(p) = safe_strlen(name);
                    unique_name(p) = copy_string_with_length(name, unique_name_length(p));
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
callq 0xec9f
movq %rax, %rbx
movabsq $0x4000000001000000, %rax # imm = 0x4000000001000000
orq %r15, %rax
movq %rax, (%rbx)
testq %r14, %r14
je 0x5c20b
cmpb $0x0, (%r14)
je 0x5c20b
xorl %eax, %eax
leaq 0x1(%rax), %r15
cmpb $0x0, 0x1(%r14,%rax)
movq %r15, %rax
jne 0x5c1fa
jmp 0x5c20e
xorl %r15d, %r15d
movq %r15, 0x28(%rbx)
leaq 0x1(%r15), %rdi
callq 0x8480
movq %rax, %r12
testq %r15, %r15
je 0x5c231
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x83e0
movb $0x0, (%r12,%r15)
movq %r12, 0x20(%rbx)
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: define_bool_function
static s7_pointer define_bool_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int optional_args, const char *doc, s7_pointer signature, int32_t sym_to_type,
                        void (*marker)(s7_pointer p, s7_int top),
                        bool simple, s7_function bool_setter)
                {
                    s7_pointer func, sym;
                    func = s7_make_typed_function(sc, name, fnc, 1, optional_args, false, doc, signature);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    if (sym_to_type != T_FREE)
                        symbol_set_type(sym, sym_to_type);
                    c_function_symbol(func) = sym;
                    c_function_set_marker(func, marker);
                    if (simple) c_function_set_has_simple_elements(func);
                    c_function_set_bool_setter(func, s7_make_function(sc, name, bool_setter, 2, 0, false, NULL));
                    c_function_set_has_bool_setter(func);
                    return(sym);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %rcx, %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %r8, (%rsp)
movl $0x1, %ecx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x3ddd8
movq %rax, %r15
orb $0x20, 0x2(%rax)
testq %r12, %r12
je 0x5c6f3
movq 0x8(%r15), %rax
movq %r12, 0x38(%rax)
movb 0x50(%rsp), %r13b
movq 0x48(%rsp), %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9afc
movq %rax, %r12
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbfdc
movl 0x40(%rsp), %ecx
testl %ecx, %ecx
je 0x5c734
movq 0x8(%r12), %rax
movq 0x20(%rax), %rax
movb %cl, 0x10(%rax)
movq 0x58(%rsp), %rdx
movq 0x8(%r15), %rax
movq %r12, 0x58(%rax)
movq 0x8(%r15), %rax
movq %rbp, 0x60(%rax)
testb %r13b, %r13b
je 0x5c753
orb $0x1, 0x7(%r15)
movq $0x0, (%rsp)
movl $0x2, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3ddd8
movq 0x8(%r15), %rcx
movq %rax, 0x50(%rcx)
orb $0x2, 0x6(%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: mark_symbol_vector
static void mark_symbol_vector(s7_pointer p, s7_int len)
    {
        set_mark(p);
        if (mark_function[T_SYMBOL] != mark_noop) /* else no gensyms */
        {
            s7_int i;
            s7_pointer *e;
            e = vector_elements(p);
            for (i = 0; i < len; i++)
                if (is_gensym(e[i]))
                    set_mark(e[i]);
        }
    }

// Assembly:
orb $-0x80, 0x7(%rdi)
leaq 0x2fd04(%rip), %rax     # 0x8c4d3
cmpq %rax, 0xe9fea(%rip)     # 0x1467c0
je 0x5c809
testq %rsi, %rsi
jle 0x5c809
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
movq (%rdi), %r8
btl $0x1d, %r8d
jae 0x5c801
orq %rax, %r8
movq %r8, (%rdi)
incq %rdx
cmpq %rdx, %rsi
jne 0x5c7ed
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: mark_vector_1
static void mark_vector_1(s7_pointer p, s7_int top)
    {
        s7_pointer *tp, *tend, *tend4;

        set_mark(p);

        tp = (s7_pointer *)(vector_elements(p));
        if (!tp) return;
        tend = (s7_pointer *)(tp + top);

        tend4 = (s7_pointer *)(tend - 8);
        while (tp <= tend4)
            LOOP_8(gc_mark(*tp++));
        while (tp < tend)
            gc_mark(*tp++);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
orb $-0x80, 0x7(%rdi)
movq 0x10(%rdi), %r13
testq %r13, %r13
je 0x5cd0c
leaq (,%rsi,8), %rbx
addq %r13, %rbx
leaq -0x40(,%rsi,8), %r14
addq %r13, %r14
cmpq %r14, %r13
ja 0x5cce4
leaq 0xe9b43(%rip), %r15     # 0x146770
movq %r13, %r12
movq (%r13), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5cc43
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x8(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5cc57
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x10(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5cc6b
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x18(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5cc7f
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x20(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5cc93
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x28(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5cca7
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x30(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5ccbb
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x38(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5cccf
movzbl %al, %eax
callq *(%r15,%rax,8)
leaq 0x40(%r12), %r13
cmpq %r14, %r13
jbe 0x5cc2d
addq $0x40, %r12
movq %r12, %r13
cmpq %rbx, %r13
jae 0x5cd0c
leaq 0xe9a80(%rip), %r14     # 0x146770
movq (%r13), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x5cd03
movzbl %al, %eax
callq *(%r14,%rax,8)
addq $0x8, %r13
cmpq %rbx, %r13
jb 0x5ccf0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_is_openlet
static s7_pointer g_is_openlet(s7_scheme *sc, s7_pointer args)
    {
#define H_is_openlet "(openlet? obj) returns #t is 'obj' has methods."
#define Q_is_openlet sc->pl_bt
        s7_pointer e;

        e = car(args);  /* if e is not a let, should this raise an error? -- no, easier to use this way in cond */
        check_method(sc, e, sc->is_openlet_symbol, args);
        return(make_boolean(sc, has_methods(e)));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movl $0x120, %r12d           # imm = 0x120
testb $0x40, 0x3(%rsi)
je 0x5cf06
movl $0x118, %r12d           # imm = 0x118
cmpb $0x1, 0x24c(%rbx)
jne 0x5cf06
movq %rbx, %rdi
callq 0x8a63
movq 0x1130(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x5cf06
cmpb $0x1, (%r15)
jne 0x5cf19
movq %rax, (%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x5ce5d
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r13, 0x8(%r12)
movq %rbp, 0x10(%r12)
movq %r12, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x5ceeb
movq %r12, %r13
movq 0x8(%r15), %rbp
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x5cebc
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 %rbp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r13
je 0x5ce92
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq (%rsp), %rax
jmp 0x5cf20
movq (%rbx,%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_is_c_pointer
static s7_pointer g_is_c_pointer(s7_scheme *sc, s7_pointer args)
    {
#define H_is_c_pointer "(c-pointer? obj type) returns #t if obj is a C pointer being held in s7.  If type is given, the c_pointer's type is also checked."
#define Q_is_c_pointer s7_make_signature(sc, 3, sc->is_boolean_symbol, sc->T, sc->T)

        s7_pointer p;
        p = car(args);
        if (!is_c_pointer(p))
        {
            if (!has_active_methods(sc, p)) return(sc->F);
            return(apply_boolean_method(sc, p, sc->is_c_pointer_symbol));
        }
        if (is_pair(cdr(args)))
            return(make_boolean(sc, c_pointer_type(p) == cadr(args)));
        return(sc->T);
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
cmpb $0x21, (%rsi)
jne 0x5d239
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x5d25c
movq 0x10(%rsi), %rcx
xorl %edx, %edx
cmpq 0x8(%rax), %rcx
setne %dl
movq 0x118(%rdi,%rdx,8), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x5d254
cmpb $0x0, 0x24c(%rdi)
je 0x5d254
movq 0x1000(%rdi), %rdx
jmp 0xca2f8
movq 0x120(%rdi), %rax
retq
movq 0x118(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: mark_simple_vector
static void mark_simple_vector(s7_pointer p, s7_int len)
    {
        s7_int i;
        s7_pointer *e;
        set_mark(p);
        e = vector_elements(p);
        for (i = 0; i < len; i++)
            set_mark(e[i]);
    }

// Assembly:
orb $-0x80, 0x7(%rdi)
testq %rsi, %rsi
jle 0x5d446
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
orq %rax, (%rdi)
incq %rdx
cmpq %rdx, %rsi
jne 0x5d437
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_is_rational
static s7_pointer g_is_rational(s7_scheme *sc, s7_pointer args)
    {
#define H_is_rational "(rational? obj) returns #t if obj is a rational number (either an integer or a ratio)"
#define Q_is_rational sc->pl_bt
        check_boolean_method(sc, s7_is_rational, sc->is_rational_symbol, args);
        /* in the non-gmp case, (rational? 455702434782048082459/86885567283849955830) -> #f, not #t, and similarly for exact? etc. */
    }

// Assembly:
movq 0x8(%rsi), %rsi
movzbl (%rsi), %eax
leaq 0xecda4(%rip), %rcx     # 0x14a9f0
cmpb $0x1, (%rax,%rcx)
jne 0x5dc5a
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x5dc75
cmpb $0x0, 0x24c(%rdi)
je 0x5dc75
movq 0x1178(%rdi), %rdx
jmp 0xca2f8
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_is_list
static s7_pointer g_is_list(s7_scheme *sc, s7_pointer args)
                {
#define H_is_list "(list? obj) returns #t if obj is a pair or null"
#define Q_is_list sc->pl_bt
#define is_a_list(p) s7_is_list(sc, p)
                    check_boolean_method(sc, is_a_list, sc->is_list_symbol, args);
                }

// Assembly:
movq 0x8(%rsi), %rsi
movb (%rsi), %al
decb %al
cmpb $0x1, %al
ja 0x5e008
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x5e023
cmpb $0x0, 0x24c(%rdi)
je 0x5e023
movq 0x10f0(%rdi), %rdx
jmp 0xca2f8
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: b_is_proper_list_setter
static s7_pointer b_is_proper_list_setter(s7_scheme *sc, s7_pointer args)
                {
                    if (s7_is_proper_list(sc, car(args)))
                        return(cadr(args));
                    return(s7_error(sc, sc->wrong_type_arg_symbol,
                                set_elist_5(sc, wrap_string(sc, "set! ~S, ~S is ~A but should be ~A", 34),
                                    car(args), cadr(args), prepackaged_type_names[type(cadr(args))], wrap_string(sc, "a proper list", 13))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x39d6f
testb %al, %al
je 0x5ead9
movq 0x10(%r15), %rax
movq 0x8(%rax), %r14
jmp 0x5eb9a
movq 0x1940(%rbx), %r14
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0xbc9af(%rip), %rcx     # 0x11b4b3
movq %rcx, 0x10(%rax)
movq $0x22, 0x8(%rax)
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
movq 0x8(%rdx), %rdx
movzbl (%rdx), %esi
leaq 0xebf3a(%rip), %rdi     # 0x14aa60
movq (%rdi,%rsi,8), %rsi
movq 0x820(%rbx), %rdi
movslq 0x7dc(%rbx), %r8
movq (%rdi,%r8,8), %rdi
incl %r8d
andl $0x7, %r8d
movl %r8d, 0x7dc(%rbx)
leaq 0xbad9d(%rip), %r8      # 0x1198ee
movq %r8, 0x10(%rdi)
movq $0xd, 0x8(%rdi)
movq 0x6f8(%rbx), %r8
movq %rax, 0x8(%r8)
movq 0x10(%r8), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x6f8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38dfa
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_is_c_object
static s7_pointer g_is_c_object(s7_scheme *sc, s7_pointer args)
                {
#define H_is_c_object "(c-object? obj) returns #t is obj is a c-object."
#define Q_is_c_object sc->pl_bt
                    s7_pointer obj;
                    obj = car(args);
                    if (is_c_object(obj)) return(sc->T);
                    if (!has_active_methods(sc, obj)) return(sc->F);
                    return(apply_boolean_method(sc, obj, sc->is_c_object_symbol));
                }

// Assembly:
movq 0x8(%rsi), %rsi
cmpb $0x14, (%rsi)
jne 0x5ef78
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x5ef93
cmpb $0x0, 0x24c(%rdi)
je 0x5ef93
movq 0xff0(%rdi), %rdx
jmp 0xca2f8
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_table
static s7_pointer g_symbol_table(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_table "(symbol-table) returns a vector containing the current symbol-table symbols"
#define Q_symbol_table s7_make_signature(sc, 1, sc->is_vector_symbol)

        s7_pointer lst, x;
        s7_pointer *els;
        int32_t i, j, syms = 0;

        /* this can't be optimized by returning the actual symbol-table (a vector of lists), because
         *    gensyms can cause the table's lists and symbols to change at any time.  This wreaks havoc
         *    on traversals like for-each.  So, symbol-table returns a snap-shot of the table contents
         *    at the time it is called, and we call gc before making the list.  I suppose the next step
         *    is to check that we have room, and increase the heap here if necessary!
         *
         *    (define (for-each-symbol func num) (for-each (lambda (sym) (if (> num 0) (for-each-symbol func (- num 1)) (func sym))) (symbol-table)))
         *    (for-each-symbol (lambda (sym) (gensym) 1))
         */

        for (i = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                syms++;
        sc->w = make_simple_vector(sc, syms);
        els = vector_elements(sc->w);

        for (i = 0, j = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                els[j++] = car(x);

        lst = sc->w;
        sc->w = sc->nil;
        return(lst);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x110(%rdi), %rax
movq 0x148(%rdi), %rcx
movq 0x10(%rcx), %rcx
xorl %edx, %edx
xorl %esi, %esi
movq (%rcx,%rdx,8), %rdi
cmpq %rax, %rdi
je 0x5f5f1
incl %esi
movq 0x10(%rdi), %rdi
jmp 0x5f5e4
incq %rdx
cmpq $0x7fed, %rdx           # imm = 0x7FED
jne 0x5f5e0
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x3bc4f
movq %rax, 0x4d8(%rbx)
movq 0x10(%rax), %rax
movq 0x110(%rbx), %rsi
xorl %ecx, %ecx
movq %rsi, %r8
xorl %edx, %edx
movq 0x148(%rbx), %rdi
movq 0x10(%rdi), %rdi
movq (%rdi,%rcx,8), %rdi
cmpq %r8, %rdi
je 0x5f65b
movslq %edx, %rsi
leaq (%rax,%rsi,8), %r8
movq 0x8(%rdi), %rsi
movq %rsi, (%r8)
movq 0x10(%rdi), %rdi
movq 0x110(%rbx), %rsi
addq $0x8, %r8
incl %edx
cmpq %rsi, %rdi
jne 0x5f63c
jmp 0x5f65e
movq %r8, %rdi
incq %rcx
movq %rdi, %r8
cmpq $0x7fed, %rcx           # imm = 0x7FED
jne 0x5f621
movq 0x4d8(%rbx), %rax
movq %rsi, 0x4d8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_string
static s7_pointer g_symbol_to_string(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_string "(symbol->string sym) returns the symbol sym converted to a string"
#define Q_symbol_to_string s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_symbol_symbol)
        s7_pointer sym;

        sym = car(args);
        if (!is_symbol(sym))
            return(method_or_bust_one_arg(sc, sym, sc->symbol_to_string_symbol, args, T_SYMBOL));
        /* s7_make_string uses strlen which stops at an embedded null */
        return(make_string_with_length(sc, symbol_name(sym), symbol_name_length(sym)));    /* return a copy */
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x5f75f
movq 0x8(%rsi), %rax
movq 0x8(%rax), %r15
movq 0x10(%rax), %r12
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x5f6c3
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200013, (%rbx)       # imm = 0x200013
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x9357
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testq %r15, %r15
jle 0x5f704
movq %r12, %rsi
movq %r15, %rdx
callq 0x83e0
movq 0x10(%rbx), %rdi
movb $0x0, (%rdi,%r15)
movq %r15, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x5f744
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x15c0(%r14), %rdx
movq %r14, %rdi
movl $0xa, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x95069
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_value
static s7_pointer g_symbol_to_value(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_value "(symbol->value sym (env (curlet))) returns the binding of (the value associated with) the \
        symbol sym in the given environment: (let ((x 32)) (symbol->value 'x)) -> 32"
#define Q_symbol_to_value s7_make_signature(sc, 3, sc->T, sc->is_symbol_symbol, sc->is_let_symbol)
        /* (symbol->value 'x e) => (e 'x)? */

        s7_pointer sym;
        sym = car(args);

        if (!is_symbol(sym))
            return(method_or_bust(sc, sym, sc->symbol_to_value_symbol, args, T_SYMBOL, 1));

        if (is_not_null(cdr(args)))
        {
            s7_pointer local_env;

            local_env = cadr(args);
            if (local_env == sc->unlet_symbol)
                return((is_slot(initial_slot(sym))) ? slot_value(initial_slot(sym)) : sc->undefined);

            if (!is_let(local_env))
                return(method_or_bust_with_type(sc, local_env, sc->symbol_to_value_symbol, args, a_let_string, 2));

            if (local_env == sc->s7_let)
                return(g_s7_let_ref_fallback(sc, set_qlist_2(sc, local_env, sym)));

            return(s7_symbol_local_value(sc, sym, local_env));
        }

        if (is_global(sym))
            return(slot_value(global_slot(sym)));

        return(s7_symbol_value(sc, sym));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x5faa5
movq 0x10(%rcx), %rax
cmpq 0x110(%rdi), %rax
je 0x5fabd
movq 0x8(%rax), %rax
cmpq 0x1630(%rdi), %rax
je 0x5fad0
cmpb $0x1c, (%rax)
jne 0x5faf2
cmpq 0x2150(%rdi), %rax
je 0x5fb0e
movq %rax, %rdx
jmp 0xbe9a
movq 0x15c8(%rdi), %rdx
movl $0xa, %r8d
movl $0x1, %r9d
jmp 0xe42d
testb $0x1, 0x2(%rsi)
je 0x9a93
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
retq
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
addq $0x128, %rdi            # imm = 0x128
cmpb $0x20, (%rax)
leaq 0x10(%rax), %rax
cmoveq %rax, %rdi
movq (%rdi), %rax
retq
movq 0x15c8(%rdi), %rdx
movq 0xeae58(%rip), %r8      # 0x14a958
movq %rax, %rsi
movl $0x2, %r9d
jmp 0xe659
movq 0x720(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x720(%rdi), %rax
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x720(%rdi), %rsi
jmp 0x8b7c7