LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x32ee7
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x32ee7
leaq 0xa0827(%rip), %rcx     # 0xd36a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x32ee3
movsd 0x8(%rdi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x32ee7
cmpeqsd 0x8(%rsi), %xmm0
jmp 0x32ec8
movsd 0x8(%rdi), %xmm1
ucomisd %xmm1, %xmm1
jp 0x32ee7
movsd 0x10(%rdi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x32ee7
ucomisd 0x8(%rsi), %xmm1
jne 0x32ee7
jp 0x32ee7
cmpeqsd 0x10(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x32ee7
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdx, %r10
movq %rsi, %rax
andq $0x0, 0x8(%rsp)
movq %rdi, %r15
movq 0x8(%rdx), %r14
cmpb $0x13, (%r14)
jne 0x35009
testb $0x1, 0x3(%r14)
jne 0x3502b
movq 0x10(%r10), %rcx
movq 0x8(%rcx), %rbx
cmpb $0x8, (%rbx)
jne 0x35065
movq 0x8(%r14), %rdx
movq %rdx, (%rsp)
movq 0x10(%rcx), %rcx
cmpq 0x110(%r15), %rcx
je 0x35075
pushq $0x3
popq %rcx
leaq 0x8(%rsp), %r8
movq %rsp, %r9
movq %r15, %rdi
movq %rax, %rsi
movq %r10, %rdx
callq 0x7b9f4
cmpq 0x140(%r15), %rax
jne 0x3509f
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
cmpq %rdx, %rdi
jne 0x35077
jmp 0x3509c
pushq $0x13
popq %r8
pushq $0x1
popq %r9
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r10, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xcd70
movq 0xe4936(%rip), %rcx     # 0x119968
movq 0x6e8(%r15), %rdx
movq %rcx, 0x8(%rdx)
movq 0x10(%rdx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %r14, 0x8(%rax)
movq 0x6e8(%r15), %rsi
movq %r15, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x972b
pushq $0x8
popq %r8
pushq $0x2
popq %r9
movq %r15, %rdi
movq %rbx, %rsi
jmp 0x35017
xorl %edi, %edi
testq %rdx, %rdx
je 0x3509c
movb 0x8(%rbx), %al
subq %rdi, %rdx
addq 0x10(%r14), %rdi
testb %al, %al
je 0x35094
movzbl %al, %esi
callq 0x73e47
jmp 0x3509c
movq %rdx, %rsi
callq 0x78377
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35578
movq %rsi, %r14
movq %rsi, 0x4c8(%rbx)
movq 0x8(%rsi), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x354dd
movq %rbx, %rdi
callq 0x9c27
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 %r15, %r12
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0x35561
movq 0x8(%r14), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x35539
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r13, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq %rax, 0x10(%r12)
movq %rax, %r12
jmp 0x35505
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
jmp 0x3557f
movq 0x110(%rbx), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x35a39
leaq 0xe4032(%rip), %rcx     # 0x119a60
movq (%rcx,%rax,8), %rax
cmpb $0x13, (%rax)
jne 0x35a39
popq %rbx
retq
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x7d054
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xd1ba
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x8d06
movslq 0x7dc(%r14), %rcx
leal 0x1(%rcx), %edx
andl $0x7, %edx
movq 0x820(%r14), %rsi
movq (%rsi,%rcx,8), %r12
movl %edx, 0x7dc(%r14)
movq %rbp, 0x10(%r12)
movq %rax, 0x8(%r12)
testq %r13, %r13
jle 0x35b00
movq 0x1f00(%r14), %rax
movq %r13, 0x8(%rax)
movq 0x1f00(%r14), %r13
movq %r15, %rdi
callq 0x8d06
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %r8
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
movq %r15, 0x10(%r8)
movq %rax, 0x8(%r8)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcb8f
movq %r15, %rdi
callq 0x8d06
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r14)
movq %r15, 0x10(%rcx)
movq %rax, 0x8(%rcx)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x35b47
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_call_with_catch
s7_pointer s7_call_with_catch(s7_scheme *sc, s7_pointer tag, s7_pointer body, s7_pointer error_handler)
                {
                    s7_pointer p, result;

                    new_cell(sc, p, T_CATCH);
                    catch_tag(p) = tag;
                    catch_goto_loc(p) = s7_stack_top(sc);
                    catch_op_loc(p) = (int32_t)(sc->op_stack_now - sc->op_stack);
                    catch_set_handler(p, error_handler);

                    push_stack(sc, OP_CATCH, error_handler, p);
                    result = s7_call(sc, body, sc->nil);
                    /* don't unstack here -- if error caught, catch has been popped off already */

                    return(result);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x35da1
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x19, (%rax)
movq %r12, 0x18(%rax)
movq 0x50(%r14), %rcx
subq 0x48(%r14), %rcx
sarq $0x3, %rcx
movq %rcx, 0x8(%rax)
movq 0x68(%r14), %rcx
subq 0x60(%r14), %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
movq %rcx, 0x10(%rax)
movq %r15, 0x20(%rax)
movq 0x50(%r14), %rcx
movq %rax, (%rcx)
movq 0x8(%r14), %rax
movq 0x50(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%r14), %rax
movq %r15, 0x10(%rax)
movq 0x50(%r14), %rax
movq $0x1e0, 0x18(%rax)      # imm = 0x1E0
addq $0x20, 0x50(%r14)
movq 0x110(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x35e2b
// File: /workspace/github_c_makefile_star2_O2/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 0x36024
movq 0x170(%rdi), %rax
cmpb $0x23, (%rax)
jne 0x36024
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 0x3603b
movq 0x1b8(%rdi), %rax
movq 0x10(%rax), %rax
andq $0x0, 0x8(%rax)
movq 0x120(%rdi), %rax
movq 0x1c0(%rdi), %rcx
movq %rax, 0x10(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b7ea
cmpb $0x0, 0xe3b6b(%rip)     # 0x119c08
movq %rax, %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmoveq %r15, %rax
movq 0x10(%rcx), %rsi
movq %rax, 0x288(%r14)
cmpq %rbx, 0x8(%rcx)
jle 0x36125
leaq -0x4(%rbx), %rdi
pushq $0x2
popq %r8
movq %rbx, %rax
cqto
idivq %r8
movq 0xeb1fa(%rip), %r8      # 0x1212d0
leaq (%rbx,%rsi), %rdx
decq %rdx
cmpq %rax, %rdi
jl 0x360f6
movzbl (%rsi,%rdi), %r9d
cmpb $0x1, (%r8,%r9)
je 0x3610f
decq %rdi
decq %rdx
jmp 0x360dd
cmpq $0x4, %rbx
jl 0x3611c
leaq (%rsi,%rbx), %rdx
decq %rdx
movw $0x2e2e, -0x3(%rdx)     # imm = 0x2E2E
movb $0x2e, -0x1(%rdx)
jmp 0x36122
movw $0x2e2e, (%rsi,%rdi)    # imm = 0x2E2E
movb $0x2e, 0x2(%rsi,%rdi)
jmp 0x36122
addq %rbx, %rsi
movq %rsi, %rdx
movb $0x0, (%rdx)
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x28(%rdi)
cmpb $0x2f, (%rsi)
jne 0x361ad
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
movq %rax, 0x4f0(%rbx)
movq %rdx, 0x10(%rbx)
movq %rsi, (%rbx)
movq 0x10(%rsi), %r14
movq %rbx, %rdi
callq 0x36214
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 0x3620c
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)
je 0x361f7
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x35492
movq %rax, %rdx
movq %rdx, 0x10(%rbx)
movl $0x198, %esi            # imm = 0x198
movq %rbx, %rdi
callq 0xe1a8
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_call_with_location
s7_pointer s7_call_with_location(s7_scheme *sc, s7_pointer func, s7_pointer args, const char *caller, const char *file, s7_int line)
                {
                    s7_pointer result;

                    if (caller)
                    {
                        sc->s7_call_name = caller;
                        sc->s7_call_file = file;
                        sc->s7_call_line = line;
                    }
                    result = s7_call(sc, func, args);
                    if (caller)
                    {
                        sc->s7_call_name = NULL;
                        sc->s7_call_file = NULL;
                        sc->s7_call_line = -1;
                    }
                    return(result);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x365d2
movq %r14, 0x6b8(%rbx)
movq %r8, 0x6b0(%rbx)
movq %r9, 0x698(%rbx)
movq %rbx, %rdi
callq 0x35e2b
testq %r14, %r14
je 0x365f1
xorps %xmm0, %xmm0
movups %xmm0, 0x6b0(%rbx)
orq $-0x1, 0x698(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x678(%rdi)
callq 0x29472
movq %rbx, %rdi
callq 0x3663c
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq $0x1df, 0x18(%rax)      # imm = 0x1DF
addq $0x20, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: opt_func
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, (%rdi)
jb 0x366c8
movq 0x8(%rdi), %rcx
addq $0x20, %rcx
xorl %eax, %eax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x366ca
cmpl %esi, (%rcx)
je 0x366cb
addq $0x10, %rcx
jmp 0x366b6
xorl %eax, %eax
retq
movq 0x8(%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x36877
andl $0x0, 0x2258(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36881
testb %al, %al
je 0x36877
leaq 0x227f(%rip), %rax      # 0x38af4
jmp 0x36879
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x38c46
cmpq %rax, 0x10(%rsi)
je 0x38c4e
orb $0x10, 0x3(%rsi)
jmp 0x29aa4
movq 0x138(%rdi), %rax
retq
movq 0x8(%rsi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0xd35f
movq %rax, %r15
movabsq $0x4000000001000000, %rax # imm = 0x4000000001000000
orq %rbx, %rax
movq %rax, (%r15)
movq %r14, %rdi
callq 0x8d06
movq %rax, 0x28(%r15)
movq %r14, %rdi
movq %rax, %rsi
callq 0xca33
movq %rax, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: syntax
static s7_pointer syntax(s7_scheme *sc, const char *name, opcode_t op, s7_pointer min_args, s7_pointer max_args, const char *doc)
                {
                    s7_pointer x, syn;
                    uint64_t hash;
                    uint32_t loc;

                    hash = raw_string_hash((const uint8_t *)name, safe_strlen(name));
                    loc = hash % SYMBOL_TABLE_SIZE;
                    x = new_symbol(sc, name, safe_strlen(name), hash, loc);

                    syn = alloc_pointer(sc);
                    set_type(syn, T_SYNTAX | T_SYNTACTIC | T_DONT_EVAL_ARGS | T_GLOBAL | T_UNHEAP);
                    syntax_opcode(syn) = op;
                    syntax_set_symbol(syn, x);
                    syntax_min_args(syn) = integer(min_args);
                    syntax_max_args(syn) = ((max_args == max_arity) ? -1 : integer(max_args));
                    syntax_documentation(syn) = doc;

                    set_global_slot(x, make_permanent_slot(sc, x, syn));
                    set_initial_slot(x, make_permanent_slot(sc, x, syn));
                    /* set_local_slot(x, global_slot(x)); */
                    set_type_bit(x, T_SYMBOL | T_SYNTACTIC | T_GLOBAL | T_UNHEAP);
                    symbol_set_local_unchecked(x, 0LL, sc->nil);
                    symbol_set_ctr(x, 0;)
                        return(x);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8d06
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x8dae
movq %rax, %rcx
movl $0x7fed, %esi           # imm = 0x7FED
xorl %edx, %edx
divq %rsi
movq %rdx, %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9234
movq %rax, %r12
movq %rbx, %rdi
callq 0xd35f
movq %rax, %r14
movabsq $0x400000000001020a, %rax # imm = 0x400000000001020A
addq $0x1fff, %rax           # imm = 0x1FFF
movq %rax, (%r14)
movq %rbp, 0x10(%r14)
movq %r12, 0x8(%r14)
movl 0x8(%r13), %eax
movl %eax, 0x18(%r14)
cmpq %r15, 0xd173f(%rip)     # 0x11b3a8
je 0x49c71
movl 0x8(%r15), %eax
jmp 0x49c74
pushq $-0x1
popq %rax
movl %eax, 0x1c(%r14)
movq (%rsp), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x982d
movq %rax, 0x10(%r12)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x982d
movq 0x8(%r12), %rcx
movq 0x20(%rcx), %rcx
movq %rax, 0x20(%rcx)
movabsq $0x400000000001020a, %rax # imm = 0x400000000001020A
orq %rax, (%r12)
movq 0x110(%rbx), %rax
movq %rax, 0x18(%r12)
andq $0x0, 0x20(%r12)
andl $0x0, 0x28(%r12)
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_O2/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
subq $0x18, %rsp
movq %rcx, %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58(%rsp), %r13
movl 0x50(%rsp), %ebp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
pushq $0x1
popq %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x30f52
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x94d4
movq %rax, %r12
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xb123
testl %ebp, %ebp
je 0x49d6c
movq 0x8(%r12), %rax
movq 0x20(%rax), %rax
movb %bpl, 0x10(%rax)
movq 0x68(%rsp), %rdx
movq 0x8(%r15), %rax
movq %r12, 0x58(%rax)
movq 0x8(%r15), %rax
movq %r13, 0x60(%rax)
cmpb $0x0, 0x60(%rsp)
je 0x49d8d
orb $0x1, 0x7(%r15)
andq $0x0, (%rsp)
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x30d36
movq 0x8(%r15), %rcx
movq %rax, 0x50(%rcx)
orb $0x2, 0x6(%r15)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x26f9e(%rip), %rax     # 0x70da2
cmpq %rax, 0xcb9b5(%rip)     # 0x1157c0
je 0x49e42
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq 0x10(%rdi), %rcx
xorl %edx, %edx
testq %rsi, %rsi
cmovleq %rdx, %rsi
cmpq %rdx, %rsi
je 0x49e42
movq (%rcx,%rdx,8), %rdi
movq (%rdi), %r8
btl $0x1d, %r8d
jae 0x49e3d
orq %rax, %r8
movq %r8, (%rdi)
incq %rdx
jmp 0x49e24
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
orb $-0x80, 0x7(%rdi)
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x4a2a7
leaq (%rbx,%rsi,8), %r14
leaq (%rbx,%rsi,8), %r15
addq $-0x40, %r15
cmpq %r15, %rbx
ja 0x4a2a2
movq (%rbx), %rdi
callq 0x72838
movq 0x8(%rbx), %rdi
callq 0x72838
movq 0x10(%rbx), %rdi
callq 0x72838
movq 0x18(%rbx), %rdi
callq 0x72838
movq 0x20(%rbx), %rdi
callq 0x72838
movq 0x28(%rbx), %rdi
callq 0x72838
movq 0x30(%rbx), %rdi
callq 0x72838
movq 0x38(%rbx), %rdi
addq $0x40, %rbx
callq 0x72838
jmp 0x4a244
movq (%rbx), %rdi
addq $0x8, %rbx
callq 0x72838
cmpq %r14, %rbx
jb 0x4a296
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movl $0x120, %r12d           # imm = 0x120
testb $0x40, 0x3(%rsi)
je 0x4a3cd
movl $0x118, %r12d           # imm = 0x118
cmpb $0x1, 0x24c(%rbx)
jne 0x4a3cd
movq %rbx, %rdi
callq 0x88f3
movq 0x1130(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x4a3cd
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35492
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq (%rbx,%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x4a6da
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x4a6fd
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 0x4a6f5
cmpb $0x0, 0x24c(%rdi)
je 0x4a6f5
movq 0x1000(%rdi), %rdx
jmp 0x9fdf2
movq 0x120(%rdi), %rax
retq
movq 0x118(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
orb $-0x80, 0x7(%rdi)
movq 0x10(%rdi), %rcx
xorl %edx, %edx
testq %rsi, %rsi
cmovleq %rdx, %rsi
cmpq %rdx, %rsi
je 0x4a8eb
movq (%rcx,%rdx,8), %rdi
orq %rax, (%rdi)
incq %rdx
jmp 0x4a8da
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xce8ff(%rip), %rcx     # 0x1199f0
cmpb $0x1, (%rax,%rcx)
jne 0x4b0ff
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x4b11a
cmpb $0x0, 0x24c(%rdi)
je 0x4b11a
movq 0x1178(%rdi), %rdx
jmp 0x9fdf2
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b4ad
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x4b4c8
cmpb $0x0, 0x24c(%rdi)
je 0x4b4c8
movq 0x10f0(%rdi), %rdx
jmp 0x9fdf2
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2db34
testb %al, %al
je 0x4bf5c
movq 0x10(%r15), %rax
movq 0x8(%rax), %r14
jmp 0x4c01d
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 0x9b4cc(%rip), %rcx     # 0xe7453
movq %rcx, 0x10(%rax)
movq $0x22, 0x8(%rax)
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
movq 0x8(%rdx), %rdx
movzbl (%rdx), %esi
leaq 0xcdab7(%rip), %rdi     # 0x119a60
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 0x998ba(%rip), %r8      # 0xe588e
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 0x2cdc0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4c3fb
movq 0x118(%rdi), %rax
retq
testb $0x40, 0x3(%rsi)
je 0x4c416
cmpb $0x0, 0x24c(%rdi)
je 0x4c416
movq 0xff0(%rdi), %rdx
jmp 0x9fdf2
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x7fed, %rdx           # imm = 0x7FED
je 0x4c9a5
leaq (%rcx,%rdx,8), %rdi
movq (%rdi), %rdi
cmpq %rax, %rdi
je 0x4c9a0
incl %esi
addq $0x10, %rdi
jmp 0x4c990
incq %rdx
jmp 0x4c983
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x2f202
movq %rax, 0x4d8(%rbx)
movq 0x10(%rax), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq $0x7fed, %rcx           # imm = 0x7FED
je 0x4ca00
movq 0x148(%rbx), %rdi
leaq (,%rcx,8), %rsi
addq 0x10(%rdi), %rsi
movslq %edx, %rdx
movq (%rsi), %rsi
cmpq 0x110(%rbx), %rsi
je 0x4c9fb
movq 0x8(%rsi), %rdi
movq %rdi, (%rax,%rdx,8)
incq %rdx
addq $0x10, %rsi
jmp 0x4c9de
incq %rcx
jmp 0x4c9bf
movq 0x4d8(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x4ca34
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rsi
jmp 0xd11d
movq 0x15c0(%rdi), %rdx
pushq $0xa
popq %r8
jmp 0x77745
// File: /workspace/github_c_makefile_star2_O2/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 0x4cbf4
movq 0x10(%rcx), %rax
cmpq 0x110(%rdi), %rax
je 0x4cc08
movq 0x8(%rax), %rax
cmpq 0x1630(%rdi), %rax
je 0x4cc1b
cmpb $0x1c, (%rax)
jne 0x4cc3d
cmpq 0x2150(%rdi), %rax
je 0x4cc57
movq %rax, %rdx
jmp 0xb072
movq 0x15c8(%rdi), %rdx
pushq $0xa
popq %r8
pushq $0x1
popq %r9
jmp 0xcd70
testb $0x1, 0x2(%rsi)
je 0x94b4
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 0xccd0d(%rip), %r8      # 0x119958
pushq $0x2
popq %r9
movq %rax, %rsi
jmp 0xcf9a
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 0x70212
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_symbol_to_dynamic_value
static s7_pointer g_symbol_to_dynamic_value(s7_scheme *sc, s7_pointer args)
    {
#define H_symbol_to_dynamic_value "(symbol->dynamic-value sym) returns the dynamic binding of the symbol sym"
#define Q_symbol_to_dynamic_value s7_make_signature(sc, 2, sc->T, sc->is_symbol_symbol)

        s7_pointer sym, val;
        int64_t i, top_id;

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

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

        if (let_id(sc->envir) == symbol_id(sym))
            return(slot_value(local_slot(sym)));

        top_id = -1;
        val = find_dynamic_value(sc, sc->envir, sym, &top_id);
        if (top_id == symbol_id(sym))
            return(val);

        for (i = s7_stack_top(sc) - 1; i > 0; i -= 4)
            if (is_let_unchecked(stack_let(sc->stack, i))) /* OP_GC_PROTECT envir slot can be anything (even free) */
            {
                s7_pointer cur_val;
                cur_val = find_dynamic_value(sc, stack_let(sc->stack, i), sym, &top_id);
                if (cur_val != sc->unused)
                    val = cur_val;
                if (top_id == symbol_id(sym))
                    return(val);
            }

        if (val == sc->unused)
            return(s7_symbol_value(sc, sym));
        return(val);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rsi), %rbx
cmpb $0xa, (%rbx)
jne 0x4ccae
testb $0x1, 0x2(%rbx)
jne 0x4ccd9
movq 0x8(%r14), %rsi
movq 0x20(%rbx), %r13
cmpq %r13, 0x18(%rsi)
jne 0x4ccf3
movq 0x18(%rbx), %rax
jmp 0x4ccdd
movq %rsi, %rcx
movq 0x15b0(%r14), %rdx
pushq $0xa
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcd70
movq 0x10(%rbx), %rax
movq 0x10(%rax), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %r12
orq $-0x1, (%r12)
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0xc7308
movq %rax, %r15
cmpq %r13, (%r12)
je 0x4cce1
movq 0x50(%r14), %rbp
subq 0x48(%r14), %rbp
sarq $0x3, %rbp
decq %rbp
movq %rsp, %r12
testq %rbp, %rbp
jle 0x4cd60
movq 0x38(%r14), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax,%rbp,8), %rsi
cmpb $0x1c, (%rsi)
jne 0x4cd5a
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0xc7308
cmpq 0x140(%r14), %rax
cmovneq %rax, %r15
cmpq %r13, (%rsp)
je 0x4cce1
addq $-0x4, %rbp
jmp 0x4cd24
cmpq 0x140(%r14), %r15
jne 0x4cce1
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x94b4
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_string_to_keyword
static s7_pointer g_string_to_keyword(s7_scheme *sc, s7_pointer args)
    {
#define H_string_to_keyword "(string->keyword str) prepends ':' to str and defines that as a keyword"
#define Q_string_to_keyword s7_make_signature(sc, 2, sc->is_keyword_symbol, sc->is_string_symbol)

        s7_pointer str;
        str = car(args);
        if (!is_string(str))
            return(method_or_bust_one_arg(sc, str, sc->string_to_keyword_symbol, args, T_STRING));
        if ((string_length(str) == 0) ||
                (string_value(str)[0] == '\0'))
            return(s7_error(sc, sc->out_of_range_symbol, set_elist_2(sc, wrap_string(sc, "string->keyword wants a non-null string: ~S", 43), str)));
        return(s7_make_keyword(sc, string_value(str)));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x4ce10
cmpq $0x0, 0x8(%rsi)
je 0x4ce20
movq 0x10(%rsi), %rax
cmpb $0x0, (%rax)
je 0x4ce20
movq %rax, %rsi
jmp 0xb337
movq 0x1300(%rdi), %rdx
pushq $0x13
popq %r8
jmp 0x77745
movq 0x1948(%rdi), %rax
movq 0x820(%rdi), %rcx
movslq 0x7dc(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0x9a6ae(%rip), %rdx     # 0xe74f9
movq %rdx, 0x10(%rcx)
movq $0x2b, 0x8(%rcx)
movq 0x6e0(%rdi), %rdx
movq %rcx, 0x8(%rdx)
movq 0x6e0(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq %rsi, 0x8(%rcx)
movq 0x6e0(%rdi), %rdx
movq %rax, %rsi
jmp 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_keyword_to_symbol
static s7_pointer g_keyword_to_symbol(s7_scheme *sc, s7_pointer args)
    {
#define H_keyword_to_symbol "(keyword->symbol key) returns a symbol with the same name as key but no prepended colon"
#define Q_keyword_to_symbol s7_make_signature(sc, 2, sc->is_symbol_symbol, sc->is_keyword_symbol)

        s7_pointer sym;
        sym = car(args);
        if (!is_keyword(sym))
            return(method_or_bust_with_type_one_arg(sc, sym, sc->keyword_to_symbol_symbol, args, wrap_string(sc, "a keyword", 9)));
        return(keyword_symbol(sym));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
testb $-0x80, 0x6(%rsi)
jne 0x4ceeb
movq 0x1208(%rdi), %rdx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r9
movq (%rax,%r9,8), %r8
leal 0x1(%r9), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x8b46e(%rip), %rax     # 0xd8348
movq %rax, 0x10(%r8)
movq $0x9, 0x8(%r8)
jmp 0xc736d
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_outlet
static s7_pointer g_outlet(s7_scheme *sc, s7_pointer args)
    {
#define H_outlet "(outlet env) is the environment that contains env."
#define Q_outlet s7_make_signature(sc, 2, sc->is_let_symbol, sc->is_let_symbol)

        s7_pointer env;

        env = car(args);
        if (!is_let(env))
            return(s7_wrong_type_arg_error(sc, "outlet", 1, env, "a let")); /* not a method call here! */

        if ((env == sc->rootlet) ||
                (is_null(outlet(env))))
            return(sc->rootlet);
        return(outlet(env));
    }

// Assembly:
movq 0x8(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0x4cf1b
movq 0x150(%rdi), %rdx
cmpq %rdx, %rcx
je 0x4cf31
movq 0x10(%rcx), %rax
cmpq 0x110(%rdi), %rax
je 0x4cf31
retq
leaq 0x9b0a6(%rip), %rsi     # 0xe7fc8
leaq 0x963a6(%rip), %r8      # 0xe32cf
pushq $0x1
popq %rdx
jmp 0xc2b0
movq %rdx, %rax
retq