LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_set_curlet
s7_pointer s7_set_curlet(s7_scheme *sc, s7_pointer e)
    {
        s7_pointer old_e;
        old_e = sc->envir;
        sc->envir = e;

        if ((is_let(e)) && (let_id(e) > 0)) /* might be () [id=-1] or rootlet [id=0?] etc */
        {
            let_id(e) = ++sc->let_number;
            update_symbol_ids(sc, e);
        }

        return(old_e);
    }

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rbx
movq %rsi, 0x8(%rdi)
cmpb $0x1c, (%rsi)
jne 0xafc9
cmpq $0x0, 0x18(%rsi)
jle 0xafc9
movq 0x250(%rdi), %rax
incq %rax
movq %rax, 0x250(%rdi)
movq %rax, 0x18(%rsi)
callq 0xafce
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: update_symbol_ids
static void update_symbol_ids(s7_scheme *sc, s7_pointer e)
    {
        s7_pointer p;
        for (p = let_slots(e); tis_slot(p); p = next_slot(p))
        {
            s7_pointer sym;
            sym = slot_symbol(p);
            if (symbol_id(sym) != sc->let_number)
                symbol_set_local(sym, sc->let_number, p);
        }
    }

// Assembly:
addq $0x8, %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
je 0xb003
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rcx
cmpq 0x250(%rdi), %rcx
je 0xaffd
movq %rsi, 0x18(%rax)
movq 0x250(%rdi), %rcx
movq %rcx, 0x20(%rax)
incl 0x28(%rax)
addq $0x18, %rsi
jmp 0xafd2
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: symbol_to_slot
static inline s7_pointer symbol_to_slot(s7_scheme *sc, s7_pointer symbol)
    {
        s7_pointer x;
        if (let_id(sc->envir) == symbol_id(symbol))
            return(local_slot(symbol));
        for (x = sc->envir; symbol_id(symbol) < let_id(x); x = outlet(x));
        if (let_id(x) == symbol_id(symbol))
            return(local_slot(symbol));
        for (; is_let(x); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == symbol)
                    return(y);
        }
        return(global_slot(symbol));
    }

// Assembly:
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rsi), %rax
pushq $0x18
popq %rcx
cmpq %rax, %rdi
je 0xb030
cmpq %rdi, %rax
jge 0xb02e
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
jmp 0xb01f
jne 0xb035
movq (%rsi,%rcx), %rax
retq
pushq $0x10
popq %rcx
cmpb $0x1c, (%rdx)
jne 0xb030
leaq 0x8(%rdx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0xb055
cmpq %rsi, 0x8(%rax)
je 0xb034
addq $0x18, %rax
jmp 0xb041
movq 0x10(%rdx), %rdx
jmp 0xb038
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_symbol_local_value
s7_pointer s7_symbol_local_value(s7_scheme *sc, s7_pointer sym, s7_pointer local_env)
    {
        /* restrict the search to local_env outward */
        if ((local_env == sc->rootlet) || (is_global(sym)))
        {
            if (is_slot(global_slot(sym)))
                return(slot_value(global_slot(sym)));
            return(sc->undefined);
        }

        if (is_let(local_env))
        {
            s7_pointer x;

            if (let_id(local_env) == symbol_id(sym))
                return(slot_value(local_slot(sym)));
            for (x = local_env; symbol_id(sym) < let_id(x); x = outlet(x));
            if (let_id(x) == symbol_id(sym))
                return(slot_value(local_slot(sym)));

            for (; is_let(x); x = outlet(x))
            {
                s7_pointer y;
                for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                    if (slot_symbol(y) == sym)
                        return(slot_value(y));
            }
            /* need to check rootlet before giving up */
            if (is_slot(global_slot(sym)))
                return(slot_value(global_slot(sym)));

            /* (let ((e (curlet))) (let ((a 1)) (symbol->value 'a e))) -> #<undefined> not 1 */
            return(sc->undefined); /* 29-Nov-17 */
        }
        return(s7_symbol_value(sc, sym));
    }

// Assembly:
cmpq %rdx, 0x150(%rdi)
je 0xb0d1
testb $0x1, 0x2(%rsi)
jne 0xb0d1
cmpb $0x1c, (%rdx)
jne 0x94b4
movq 0x18(%rdx), %rcx
movq 0x20(%rsi), %rax
cmpq %rax, %rcx
je 0xb0a8
cmpq %rcx, %rax
jge 0xb0a6
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rcx
jmp 0xb097
jne 0xb0ae
movq 0x18(%rsi), %rax
jmp 0xb0da
cmpb $0x1c, (%rdx)
jne 0xb0d1
leaq 0x8(%rdx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0xb0cb
cmpq %rsi, 0x8(%rax)
je 0xb0da
addq $0x18, %rax
jmp 0xb0b7
movq 0x10(%rdx), %rdx
jmp 0xb0ae
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
jne 0xb0df
movq 0x10(%rax), %rax
retq
movq 0x128(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_symbol_set_value
s7_pointer s7_symbol_set_value(s7_scheme *sc, s7_pointer sym, s7_pointer val)
    {
        s7_pointer x;
        /* if immutable should this return an error? */
        x = symbol_to_slot(sc, sym);
        if (is_slot(x))
            slot_set_value(x, val); /* with_hook? */
        return(val);
    }

// Assembly:
pushq %rbx
movq %rdx, %rbx
callq 0xb00b
cmpb $0x20, (%rax)
jne 0xb0f9
movq %rbx, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_is_defined
bool s7_is_defined(s7_scheme *sc, const char *name)
    {
        s7_pointer x;
        x = s7_symbol_table_find_name(sc, name);
        if (x)
        {
            x = symbol_to_slot(sc, x);
            return(is_slot(x));
        }
        return(false);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8d24
testq %rax, %rax
je 0xb11f
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb00b
cmpb $0x20, (%rax)
sete %al
jmp 0xb121
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_define
void s7_define(s7_scheme *sc, s7_pointer envir, s7_pointer symbol, s7_pointer value)
    {
        s7_pointer x;
        if ((envir == sc->nil) ||
                (envir == sc->rootlet))
            envir = sc->shadow_rootlet;
        x = symbol_to_local_slot(sc, symbol, envir);
        if (is_slot(x))
            slot_set_value_with_hook(x, value);
        else
        {
            s7_make_slot(sc, envir, symbol, value); /* I think this means C code can override "constant" defs */
            /* if envir is sc->nil or rootlet, s7_make_slot makes a permanent_slot */
            if ((envir == sc->shadow_rootlet) &&
                    (!is_slot(global_slot(symbol))))
            {
                set_global(symbol); /* is_global => global_slot is usable */
                set_global_slot(symbol, local_slot(symbol));
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
cmpq %rsi, 0x110(%rdi)
je 0xb14a
movq %rsi, %r12
cmpq %rsi, 0x150(%r15)
jne 0xb151
movq 0x158(%r15), %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xb1df
cmpb $0x20, (%rax)
jne 0xb192
movq %rax, %r13
movq 0x200(%r15), %rsi
movq %r15, %rdi
callq 0x97c7
cmpb $0x1, (%rax)
jne 0xb1d1
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x97da
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x94fb
cmpq 0x158(%r15), %r12
jne 0xb1d5
movq 0x10(%rbx), %rax
cmpb $0x20, (%rax)
je 0xb1d5
movq (%rbx), %rax
btl $0x14, %eax
jb 0xb1c7
orq $0x10000, %rax          # imm = 0x10000
movq %rax, (%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
jmp 0xb1d5
movq %r14, 0x10(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: symbol_to_local_slot
static s7_pointer symbol_to_local_slot(s7_scheme *sc, s7_pointer symbol, s7_pointer e)
    {
        if (!is_let(e))
            return(global_slot(symbol));

        if (symbol_id(symbol) != 0)
        {
            s7_pointer y;
            for (y = let_slots(e); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == symbol)
                    return(y);
        }
        return(sc->undefined);
    }

// Assembly:
cmpb $0x1c, (%rdx)
jne 0xb206
cmpq $0x0, 0x20(%rsi)
je 0xb20f
movq %rdx, %rax
addq $0x8, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xb20f
cmpq %rsi, 0x8(%rax)
je 0xb219
addq $0x18, %rax
jmp 0xb1f2
addq $0x10, %rsi
movq %rsi, %rdi
jmp 0xb216
addq $0x128, %rdi            # imm = 0x128
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_define_variable_with_documentation
s7_pointer s7_define_variable_with_documentation(s7_scheme *sc, const char *name, s7_pointer value, const char *help)
    {
        s7_pointer sym;
        sym = s7_define_variable(sc, name, value);
        symbol_set_has_help(sym);
        symbol_set_help(sym, copy_string(help));
        return(sym);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
callq 0xb21a
movq %rax, %r14
movq 0x8(%rax), %rax
orq $0x20000000, (%rax)     # imm = 0x20000000
movq %rbx, %rdi
callq 0xb284
movq 0x8(%r14), %rcx
movq 0x20(%rcx), %rcx
movq %rax, 0x18(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_define_constant
s7_pointer s7_define_constant(s7_scheme *sc, const char *name, s7_pointer value)
    {
        s7_pointer sym;
        sym = make_symbol(sc, name);
        s7_define(sc, sc->nil, sym, value);
        set_immutable(sym);
        set_possibly_constant(sym);
        set_immutable(global_slot(sym));
        set_immutable(local_slot(sym));
        return(sym);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x94d4
movq %rax, %r15
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xb123
movq (%r15), %rax
movq 0x10(%r15), %rcx
movl $0x1000000, %edx        # imm = 0x1000000
movq %rax, %rsi
orq %rdx, %rsi
movq %rsi, (%r15)
shrq $0x30, %rax
orl $0x1, %eax
movw %ax, 0x6(%r15)
orq %rdx, (%rcx)
movq 0x18(%r15), %rax
orq %rdx, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_define_constant_with_documentation
s7_pointer s7_define_constant_with_documentation(s7_scheme *sc, const char *name, s7_pointer value, const char *help)
    {
        s7_pointer sym;
        sym = s7_define_constant(sc, name, value);
        symbol_set_has_help(sym);
        symbol_set_help(sym, copy_string(help));
        return(value); /* inconsistent with variable above, but consistent with define_function? */
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
callq 0xb299
movq %rax, %r15
movq 0x8(%rax), %rax
orq $0x20000000, (%rax)     # imm = 0x20000000
movq %rbx, %rdi
callq 0xb284
movq 0x8(%r15), %rcx
movq 0x20(%rcx), %rcx
movq %rax, 0x18(%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_make_keyword
s7_pointer s7_make_keyword(s7_scheme *sc, const char *key)
    {
        s7_pointer sym;
        block_t *b;
        char *name;
        size_t slen;
        slen = (size_t)safe_strlen(key);
        b = mallocate(sc, slen + 2);
        name = (char *)block_data(b);
        catstrs_direct(name, ":", key, NULL);              /* use catstrs_direct to get around a bug in gcc 8.1 */
        sym = make_symbol_with_length(sc, name, slen + 1); /* keyword slot etc taken care of here (in new_symbol actually) */
        liberate(sc, b);
        return(sym);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8d06
movq %rax, %r15
leaq 0x2(%rax), %rsi
movq %rbx, %rdi
callq 0x9037
movq %rax, %r12
movq (%rax), %r13
leaq 0xd7459(%rip), %rsi     # 0xe27c3
movq %r13, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xb3a5
incq %r15
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x8c3b
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9439
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: catstrs_direct
static size_t catstrs_direct(char *dst, const char *s1, ...) /* NULL-terminated arg list, dst is destination only (assumed empty), all args known to fit in dst */
    {
        const char *s;
        char *d;
        va_list ap;
        d = dst;
        va_start(ap, s1);
        for (s = s1; s != NULL; s = va_arg(ap, const char *))
            while (*s) {*d++ = *s++;}
        *d = '\0';
        va_end (ap);
        return(d - dst);
    }

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xb3e9
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
movq %rdi, %rax
testq %rsi, %rsi
je 0xb44d
movb (%rsi), %cl
testb %cl, %cl
je 0xb41f
incq %rsi
movb %cl, (%rax)
incq %rax
jmp 0xb40f
movl -0x80(%rsp), %edx
cmpq $0x28, %rdx
ja 0xb43a
movq %rdx, %rcx
addq -0x70(%rsp), %rcx
addl $0x8, %edx
movl %edx, -0x80(%rsp)
jmp 0xb448
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x78(%rsp)
movq (%rcx), %rsi
jmp 0xb40a
movb $0x0, (%rax)
subq %rdi, %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_make_c_pointer_with_type
s7_pointer s7_make_c_pointer_with_type(s7_scheme *sc, void *ptr, s7_pointer type, s7_pointer info)
    {
        s7_pointer x;
        new_cell(sc, x, T_C_POINTER);
        c_pointer(x) = ptr;
        c_pointer_type(x) = type;
        c_pointer_info(x) = info;
        c_pointer_weak1(x) = sc->F;
        c_pointer_weak2(x) = sc->F;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xb4d9
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x21, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq 0x120(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%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: s7_make_continuation
s7_pointer s7_make_continuation(s7_scheme *sc)
    {
        s7_pointer x, stack;
        int64_t loc;
        block_t *block;

        loc = s7_stack_top(sc);
        stack = copy_stack(sc, sc->stack, loc);
        sc->temp8 = stack;

        new_cell(sc, x, T_CONTINUATION);
        block = mallocate_block(sc);
        continuation_block(x) = block;
        continuation_set_stack(x, stack);
        continuation_stack_size(x) = vector_length(continuation_stack(x));   /* copy_stack can return a smaller stack than the current one */
        continuation_stack_start(x) = stack_elements(continuation_stack(x));
        continuation_stack_end(x) = (s7_pointer *)(continuation_stack_start(x) + loc);
        continuation_op_stack(x) = copy_op_stack(sc);
        continuation_op_loc(x) = (int32_t)(sc->op_stack_now - sc->op_stack);
        continuation_op_size(x) = sc->op_stack_size;
        continuation_key(x) = find_any_baffle(sc);
        sc->temp8 = sc->nil;

        add_continuation(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rsi
movq 0x50(%rdi), %r12
subq 0x48(%rdi), %r12
movq %r12, %rdx
sarq $0x3, %rdx
callq 0xb6b1
movq %rax, %r15
movq %rax, 0x530(%rbx)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb57e
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x25, (%r14)
movq %rbx, %rdi
callq 0xb93f
movq %rax, 0x8(%r14)
movq %r15, 0x10(%r14)
movl 0x8(%r15), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%r14)
addq %rax, %r12
movq %r12, 0x28(%r14)
movq 0x68(%rbx), %r12
subq 0x60(%rbx), %r12
shrq $0x3, %r12
movslq %r12d, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2f202
testl %r15d, %r15d
jle 0xb5fd
movq 0x60(%rbx), %rcx
movq 0x10(%rax), %rdx
xorl %esi, %esi
testl %r12d, %r12d
jle 0xb5fd
movq (%rcx,%rsi), %rdi
movq %rdi, (%rdx,%rsi)
decl %r12d
addq $0x8, %rsi
jmp 0xb5e7
movq %rax, 0x18(%r14)
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
shrq $0x3, %rax
movq 0x8(%r14), %rcx
movl %eax, 0x1c(%rcx)
movl 0x78(%rbx), %eax
movq 0x8(%r14), %rcx
movl %eax, 0x20(%rcx)
pushq $-0x1
popq %rax
cmpq $0x0, 0xa98(%rbx)
jle 0xb663
leaq 0x8(%rbx), %rcx
movq (%rcx), %rcx
cmpb $0x1c, (%rcx)
jne 0xb696
leaq 0x8(%rcx), %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0xb656
movq 0x8(%rdx), %rsi
cmpq 0x17d8(%rbx), %rsi
je 0xb65c
addq $0x18, %rdx
jmp 0xb63b
addq $0x10, %rcx
jmp 0xb62f
movq 0x10(%rdx), %rcx
movl 0x8(%rcx), %eax
movq 0x8(%r14), %rcx
movl %eax, 0x24(%rcx)
movq 0x110(%rbx), %rax
movq %rax, 0x530(%rbx)
movq 0x760(%rbx), %rdi
movq %r14, %rsi
callq 0xb999
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x17d8(%rbx), %rcx
movq 0x10(%rcx), %rcx
cmpb $0x20, (%rcx)
jne 0xb663
movq 0x10(%rcx), %rcx
cmpb $0x27, (%rcx)
je 0xb660
jmp 0xb663
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: mallocate_block
static inline block_t *mallocate_block(s7_scheme *sc)
    {
        block_t *p;
        if (!sc->block_lists[BLOCK_LIST])
            fill_block_list(sc);                /* this is much faster than allocating blocks as needed */
        p = sc->block_lists[BLOCK_LIST];
        sc->block_lists[BLOCK_LIST] = (block_t *)(block_next(p));
        /* block_next(p) = NULL; */
        block_index(p) = BLOCK_LIST;
        return(p);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x838(%rdi), %rax
testq %rax, %rax
jne 0xb988
movl $0x2800, %edi           # imm = 0x2800
callq 0x8480
movq %rax, 0x838(%rbx)
movq %rax, %rcx
addq $0x28, %rcx
movl $0xff, %edx
subl $0x1, %edx
jb 0xb97f
movq %rcx, -0x10(%rcx)
andl $0x0, -0x20(%rcx)
addq $0x28, %rcx
jmp 0xb96c
andq $0x0, -0x10(%rcx)
andl $0x0, -0x20(%rcx)
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%rbx)
andl $0x0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: add_to_gc_list
static inline void add_to_gc_list(gc_list *gp, s7_pointer p)
    {
        if (gp->loc == gp->size)
        {
            gp->size *= 2;
            gp->list = (s7_pointer *)realloc(gp->list, gp->size * sizeof(s7_pointer));
        }
        gp->list[gp->loc++] = p;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rdi), %rsi
cmpq 0x8(%rdi), %rsi
jne 0xb9cb
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)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_rationalize
s7_pointer s7_rationalize(s7_scheme *sc, s7_double x, s7_double error)
    {
        s7_int numer = 0, denom = 1;
        if (c_rationalize(x, error, &numer, &denom))
            return(s7_make_ratio(sc, numer, denom));
        return(make_real(sc, x));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rdi, %r14
movq %rsp, %r15
movq $0x1, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba8a
movq (%rbx), %rsi
movq (%r15), %rdx
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xbd87
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_make_integer
s7_pointer s7_make_integer(s7_scheme *sc, s7_int n)
    {
        s7_pointer x;
        if (is_small(n))              /* ((n >= 0) && (n < NUM_SMALL_INTS)) is slower */
            return(small_int(n));

        new_cell(sc, x, T_INTEGER);
        integer(x) = n;
        return(x);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x7ff, %rsi            # imm = 0x7FF
ja 0xc066
leaq 0x1098f0(%rip), %rax    # 0x115950
movq (%rax,%rbx,8), %rax
jmp 0xc0a2
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xc088
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_make_real
s7_pointer s7_make_real(s7_scheme *sc, s7_double n)
    {
        s7_pointer x;
        new_cell(sc, x, T_REAL);
        set_real(x, n);
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xc0dd
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_make_mutable_real
s7_pointer s7_make_mutable_real(s7_scheme *sc, s7_double n)
    {
        s7_pointer x;
        new_cell(sc, x, T_REAL | T_MUTABLE | T_IMMUTABLE);
        set_real(x, n);
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xc131
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x500000d, (%rax)      # imm = 0x500000D
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_make_complex
s7_pointer s7_make_complex(s7_scheme *sc, s7_double a, s7_double b)
    {
        s7_pointer x;
        if (b == 0.0)
        {
            new_cell(sc, x, T_REAL);
            set_real(x, a);
        }
        else
        {
            new_cell(sc, x, T_COMPLEX);
            set_real_part(x, a);
            set_imag_part(x, b);
        }
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
movq 0x90(%rdi), %rax
movq 0x98(%rdi), %rcx
jne 0xc1af
jp 0xc1af
cmpq %rcx, %rax
ja 0xc192
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x9c27
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0xc1f9
cmpq %rcx, %rax
ja 0xc1d9
movq %rbx, %rdi
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xe, (%rax)
movsd %xmm0, 0x8(%rax)
movsd %xmm1, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_number_to_real_with_caller
s7_double s7_number_to_real_with_caller(s7_scheme *sc, s7_pointer x, const char *caller)
    {
        if (is_t_real(x))
            return(real(x));

        switch (type(x))
        {
            case T_INTEGER:     return((s7_double)integer(x));
            case T_RATIO:       return((s7_double)numerator(x) / (s7_double)denominator(x));
            case T_REAL:        return(real(x));
#if WITH_GMP
            case T_BIG_INTEGER: return((s7_double)big_integer_to_s7_int(big_integer(x)));
            case T_BIG_RATIO:   return((s7_double)((long_double)big_integer_to_s7_int(mpq_numref(big_ratio(x))) /
                                            (long_double)big_integer_to_s7_int(mpq_denref(big_ratio(x)))));
            case T_BIG_REAL:    return((s7_double)mpfr_get_d(big_real(x), GMP_RNDN));
#endif
        }
        s7_wrong_type_arg_error(sc, caller, 0, x, "a real number");
        return(0.0);
    }

// Assembly:
movq %rsi, %rcx
movzbl (%rsi), %eax
cmpl $0xb, %eax
je 0xc28f
cmpl $0xc, %eax
je 0xc27e
cmpl $0xd, %eax
jne 0xc296
movsd 0x8(%rcx), %xmm0
retq
cvtsi2sdq 0x8(%rcx), %xmm0
cvtsi2sdq 0x10(%rcx), %xmm1
divsd %xmm1, %xmm0
retq
cvtsi2sdq 0x8(%rcx), %xmm0
retq
pushq %rax
leaq 0xcb553(%rip), %r8      # 0xd77f1
movq %rdx, %rsi
xorl %edx, %edx
callq 0xc2b0
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_wrong_type_arg_error
s7_pointer s7_wrong_type_arg_error(s7_scheme *sc, const char *caller, s7_int arg_n, s7_pointer arg, const char *descr)
                {
                    if (arg_n > 0)
                        return(wrong_type_arg_error_prepackaged(sc, wrap_string(sc, caller, safe_strlen(caller)), wrap_integer1(sc, arg_n),
                                    arg, type_name_string(sc, arg), wrap_string(sc, descr, safe_strlen(descr))));
                    return(simple_wrong_type_arg_error_prepackaged(sc, wrap_string(sc, caller, safe_strlen(caller)), arg,
                                type_name_string(sc, 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 0xc371
movq 0x1f00(%r14), %rax
movq %r13, 0x8(%rax)
movq 0x1f00(%r14), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x35a1a
movq %rax, %rbp
movq %r15, %rdi
callq 0x8d06
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %r9
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
movq %r15, 0x10(%r9)
movq %rax, 0x8(%r9)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq %rbp, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9bbb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x35a1a
movq %rax, %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 %rbx, %rdx
movq %r13, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_number_to_string
char *s7_number_to_string(s7_scheme *sc, s7_pointer obj, s7_int radix)
    {
        s7_int nlen = 0;
        block_t *b;
        char *str;
        b = number_to_string_with_radix(sc, obj, radix, 0, 20, 'g', &nlen);  /* (log top 10) so we get all the digits in base 10 (??) */
        str = copy_string_with_length((char *)block_data(b), nlen);
        liberate(sc, b);
        return(str);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %r15, (%rsp)
pushq $0x14
popq %r8
pushq $0x67
popq %r9
xorl %ecx, %ecx
callq 0xc49c
movq %rax, %r14
movq (%rax), %rdi
movq (%r15), %rsi
callq 0xca33
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9439
movq %r15, %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_string_with_length
static char *copy_string_with_length(const char *str, s7_int len)
    {
        char *newstr;
#if S7_DEBUGGING
        if ((len <= 0) || (!str))
            fprintf(stderr, "%s[%d]: len: %" print_s7_int ", str: %s\n", __func__, __LINE__, len, str);
#endif
        newstr = (char *)malloc(len + 1);
        if (len != 0)
            memcpy((void *)newstr, (void *)str, len);
        newstr[len] = '\0';
        return(newstr);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1(%rsi), %rdi
callq 0x8480
movq %rax, %r14
testq %rbx, %rbx
je 0xca5d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x83e0
movb $0x0, (%r14,%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: rationalize_p_d
s7_pointer rationalize_p_d(s7_scheme *sc, s7_double x)
    {
        if ((is_NaN(x)) || (is_inf(x)))
            return(out_of_range(sc, sc->rationalize_symbol, small_int(1), make_real(sc, x), a_normal_real_string));
        if ((x > 9.2233720368548e+18) || (x < -9.2233720368548e+18))
            return(out_of_range(sc, sc->rationalize_symbol, small_int(1), make_real(sc, x), its_too_large_string));
        return(s7_rationalize(sc, x, sc->default_rationalize_error));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xcaef
movq 0x1438(%rbx), %rax
movq 0x8(%rax), %r14
movq 0x108eb6(%rip), %r15    # 0x115958
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcacb
movq %rbx, %rdi
movdqa %xmm0, (%rsp)
callq 0x9c27
movdqa (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0xd, (%rcx)
movq %xmm0, 0x8(%rcx)
movq 0x10cf4b(%rip), %r8     # 0x119a38
jmp 0xcb62
movdqa 0xc93c9(%rip), %xmm1    # 0xd5ec0
pand %xmm0, %xmm1
ucomisd 0xc553d(%rip), %xmm1    # 0xd2040
jbe 0xcb76
movq 0x1438(%rbx), %rax
movq 0x8(%rax), %r14
movq 0x108e41(%rip), %r15    # 0x115958
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcb40
movq %rbx, %rdi
movdqa %xmm0, (%rsp)
callq 0x9c27
movdqa (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0xd, (%rcx)
movq %xmm0, 0x8(%rcx)
movq 0x10cede(%rip), %r8     # 0x119a40
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xcb8f
movsd 0x258(%rbx), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xba49
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_real_part
s7_double s7_real_part(s7_pointer x)
    {
        switch(type(x))
        {
            case T_INTEGER:     return((s7_double)integer(x));
            case T_RATIO:       return(fraction(x));
            case T_REAL:        return(real(x));
            case T_COMPLEX:     return(real_part(x));
#if WITH_GMP
            case T_BIG_INTEGER: return((s7_double)big_integer_to_s7_int(big_integer(x)));
            case T_BIG_RATIO:   return((s7_double)((long_double)big_integer_to_s7_int(mpq_numref(big_ratio(x))) / (long_double)big_integer_to_s7_int(mpq_denref(big_ratio(x)))));
            case T_BIG_REAL:    return((s7_double)mpfr_get_d(big_real(x), GMP_RNDN));
            case T_BIG_COMPLEX: return((s7_double)mpfr_get_d(mpc_realref(big_complex(x)), GMP_RNDN));
#endif
        }
        return(0.0);
    }

// Assembly:
movzbl (%rdi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xcc18
leaq 0xc55d1(%rip), %rcx     # 0xd21ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x8(%rdi), %xmm0
retq
cvtsi2sdq 0x8(%rdi), %xmm0
retq
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rax, -0x8(%rsp)
fildll -0x8(%rsp)
movq %rcx, -0x10(%rsp)
fildll -0x10(%rsp)
fdivrp %st, %st(1)
fstpl -0x18(%rsp)
movsd -0x18(%rsp), %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_random_state
s7_pointer s7_random_state(s7_scheme *sc, s7_pointer args)
    {
#define H_random_state "(random-state seed (carry plausible-default)) returns a new random number state initialized with 'seed'. \
        Pass this as the second argument to 'random' to get a repeatable random number sequence:\n\
        (let ((seed (random-state 1234))) (random 1.0 seed))"
#define Q_random_state s7_make_circular_signature(sc, 1, 2, sc->is_random_state_symbol, sc->is_integer_symbol)

        s7_pointer r1, r2, p;
        s7_int i1, i2;

        r1 = car(args);
        if (!s7_is_integer(r1))
            return(method_or_bust(sc, r1, sc->random_state_symbol, args, T_INTEGER, 1));
        i1 = integer(r1);
        if (i1 < 0)
            return(out_of_range(sc, sc->random_state_symbol, small_int(1), r1, its_negative_string));

        if (is_null(cdr(args)))
        {
            new_cell(sc, p, T_RANDOM_STATE);
            random_seed(p) = (uint64_t)i1;
            random_carry(p) = 1675393560;                          /* should this be dependent on the seed? */
            return(p);
        }

        r2 = cadr(args);
        if (!s7_is_integer(r2))
            return(method_or_bust(sc, r2, sc->random_state_symbol, args, T_INTEGER, 2));
        i2 = integer(r2);
        if (i2 < 0)
            return(out_of_range(sc, sc->random_state_symbol, small_int(2), r2, its_negative_string));

        new_cell(sc, p, T_RANDOM_STATE);
        random_seed(p) = (uint64_t)i1;
        random_carry(p) = (uint64_t)i2;
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpb $0xb, (%rax)
jne 0xccb8
movq 0x8(%rax), %r14
testq %r14, %r14
js 0xccd7
movq 0x10(%rcx), %rax
cmpq 0x110(%rbx), %rax
je 0xcd00
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0xcd47
movq 0x8(%rax), %r15
testq %r15, %r15
js 0xcd59
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcc95
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x24, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
jmp 0xcd41
movq 0x1420(%rbx), %rdx
pushq $0xb
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xcd70
movq 0x1420(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x108c6f(%rip), %rdx    # 0x115958
movq 0x10cd58(%rip), %r8     # 0x119a48
movq %rbx, %rdi
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xcb8f
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcd1f
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x24, (%rax)
movq %r14, 0x8(%rax)
movq $0x63dc7a18, 0x10(%rax) # imm = 0x63DC7A18
popq %rbx
popq %r14
popq %r15
retq
movq 0x1420(%rbx), %rdx
pushq $0xb
popq %r8
pushq $0x2
jmp 0xccc5
movq 0x1420(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0x108bf5(%rip), %rdx    # 0x115960
jmp 0xcce9
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_random_state_to_list
s7_pointer s7_random_state_to_list(s7_scheme *sc, s7_pointer args)
    {
#define H_random_state_to_list "(random-state->list r) returns the random state object as a list.\
        You can later apply random-state to this list to continue a random number sequence from any point."
#define Q_random_state_to_list s7_make_signature(sc, 2, sc->is_pair_symbol, sc->is_random_state_symbol)

#if WITH_GMP
        if ((is_pair(args)) &&
                (!is_random_state(car(args))))
            return(method_or_bust_with_type(sc, car(args), sc->random_state_to_list_symbol, args, a_random_state_object_string, 1));
        return(sc->nil);
#else
        s7_pointer r;
        if (is_null(args))
            r = sc->default_rng;
        else
        {
            r = car(args);
            if (!is_random_state(r))
                return(method_or_bust_with_type(sc, r, sc->random_state_to_list_symbol, args, a_random_state_object_string, 1));
        }
        return(list_2(sc, make_integer(sc, random_seed(r)), make_integer(sc, random_carry(r))));
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, 0x110(%rdi)
je 0xce84
movq %rsi, %rcx
movq 0x8(%rsi), %r14
cmpb $0x24, (%r14)
je 0xce8b
movq 0x1428(%rbx), %rdx
movq 0x10cbe4(%rip), %r8     # 0x119a50
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
movq 0xaa0(%rbx), %r14
movq 0x8(%r14), %r13
leaq 0x108aba(%rip), %r12    # 0x115950
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0xcea5
movq (%r12,%r13,8), %r15
jmp 0xcede
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcec4
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0xb, (%r15)
movq %r13, 0x8(%r15)
movq 0x10(%r14), %r13
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0xcef1
movq (%r12,%r13,8), %r14
jmp 0xcf2a
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xcf10
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0xb, (%r14)
movq %r13, 0x8(%r14)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xcf50
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rax), %rax
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %rcx, 0x10(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_set_default_random_state
void s7_set_default_random_state(s7_scheme *sc, s7_int seed, s7_int carry)
    {
#if (!WITH_GMP)
        s7_pointer p;
        new_cell(sc, p, T_RANDOM_STATE);
        random_seed(p) = (uint64_t)seed;
        random_carry(p) = (uint64_t)carry;
        sc->default_rng = p;
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xd08b
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x24, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0xaa0(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_string_with_length
static inline s7_pointer make_string_with_length(s7_scheme *sc, const char *str, s7_int len)
    {
        s7_pointer x;
        new_cell(sc, x, T_STRING | T_SAFE_PROCEDURE);
        string_block(x) = mallocate(sc, len + 1);
        string_value(x) = (char *)block_data(string_block(x));
        if (len > 0)
            memcpy((void *)string_value(x), (void *)str, len);
        string_value(x)[len] = 0;
        string_length(x) = len;
        string_hash(x) = 0;
        add_string(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xd14d
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200013, (%r15)       # imm = 0x200013
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x9037
movq %rax, 0x20(%r15)
movq (%rax), %rdi
movq %rdi, 0x10(%r15)
testq %r14, %r14
jle 0xd18e
movq %r12, %rsi
movq %r14, %rdx
callq 0x83e0
movq 0x10(%r15), %rdi
movb $0x0, (%rdi,%r14)
movq %r14, 0x8(%r15)
andq $0x0, 0x18(%r15)
movq 0x738(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %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: make_empty_string
static s7_pointer make_empty_string(s7_scheme *sc, s7_int len, char fill)
    {
        s7_pointer x;
        block_t *b;
        new_cell(sc, x, T_STRING);
        b = mallocate(sc, len + 1);                   /* terminated_string_read_white_space needs the second #\null (is this still the case?) */
        string_block(x) = b;
        string_value(x) = (char *)block_data(b);
        if ((fill != '\0') && (len > 0))
            local_memset((void *)(string_value(x)), fill, len);
        string_value(x)[len] = 0;
        string_hash(x) = 0;
        string_length(x) = len;
        add_string(sc, x);
        return(x);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xd267
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x13, (%r15)
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x9037
movq %rax, 0x20(%r15)
movq (%rax), %rdi
movq %rdi, 0x10(%r15)
testb %bpl, %bpl
sete %al
testq %r14, %r14
setle %cl
orb %al, %cl
jne 0xd2b4
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x73e47
movq 0x10(%r15), %rdi
movb $0x0, (%rdi,%r14)
andq $0x0, 0x18(%r15)
movq %r14, 0x8(%r15)
movq 0x738(%rbx), %rdi
movq %r15, %rsi
callq 0xb999
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_make_permanent_string
s7_pointer s7_make_permanent_string(s7_scheme *sc, const char *str)
    {
        /* for the symbol table which is never GC'd */
        s7_pointer x;
        x = alloc_pointer(sc);
#if S7_DEBUGGING
        permanent_strings++;
#endif
        set_type(x, T_STRING | T_IMMUTABLE | T_UNHEAP);
        if (str)
        {
            s7_int len;
            len = safe_strlen(str);
            string_length(x) = len;
            /* string_block(x) = mallocate_block(); */
            string_block(x) = NULL;
            string_value(x) = (char *)alloc_permanent_string(sc, len + 1);
            memcpy((void *)string_value(x), (void *)str, len);
            string_value(x)[len] = 0;
        }
        else
        {
            string_value(x) = NULL;
            string_length(x) = 0;
        }
        string_hash(x) = 0;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xd35f
movq %rax, %rbx
movabsq $0x4000000001000013, %rax # imm = 0x4000000001000013
movq %rax, (%rbx)
testq %r14, %r14
je 0xd344
movq %r14, %rdi
callq 0x8d06
movq %rax, %r12
movq %rax, 0x8(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0xd3b1
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x83e0
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r12)
jmp 0xd34b
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: alloc_pointer
static s7_cell *alloc_pointer(s7_scheme *sc)
    {
        if (sc->alloc_pointer_k == ALLOC_POINTER_SIZE)     /* if either no current block or the block is used up, make a new block */
        {
            sc->permanent_cells += ALLOC_POINTER_SIZE;
            sc->alloc_pointer_cells = (s7_cell *)calloc(ALLOC_POINTER_SIZE, sizeof(s7_cell));
            sc->alloc_pointer_k = 0;
        }
        return(&(sc->alloc_pointer_cells[sc->alloc_pointer_k++]));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x7f0(%rdi), %ecx
cmpl $0x100, %ecx            # imm = 0x100
jne 0xd393
addl $0x100, 0x7d8(%rbx)     # imm = 0x100
pushq $0x30
popq %rsi
movl $0x100, %edi            # imm = 0x100
callq 0x8360
movq %rax, 0x800(%rbx)
xorl %ecx, %ecx
jmp 0xd39a
movq 0x800(%rbx), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x7f0(%rbx)
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rax, %rcx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: alloc_permanent_string
static inline char *alloc_permanent_string(s7_scheme *sc, size_t len)
    {
#define ALLOC_STRING_SIZE 65536 /* 32768 -- current size is probably still too small, but the timing tests don't seem to care */
#define ALLOC_MAX_STRING 512    /* 256 -- sets max size of block space lost at the end (1/2 size I think), but smaller = more direct malloc calls */
        char *result;
        size_t next_k;

        len = (len + 7) & (~7);            /* 8-byte aligned -- more than half the time, len is already 8-byte aligned */
        next_k = sc->alloc_string_k + len;
        if (next_k > ALLOC_STRING_SIZE)    /* was >= */
        {
            if (len >= ALLOC_MAX_STRING)
            {
#if S7_DEBUGGING
                permanent_string_len += len;
#endif
                return((char *)malloc(len));
            }
#if S7_DEBUGGING
            permanent_string_len += ALLOC_STRING_SIZE;
#endif
            /* fprintf(stderr, "new heap: %ld lost\n", ALLOC_STRING_SIZE - sc->alloc_string_k); */
            sc->alloc_string_cells = (char *)malloc(ALLOC_STRING_SIZE);
            sc->alloc_string_k = 0;
            next_k = len;
        }
        result = &(sc->alloc_string_cells[sc->alloc_string_k]);
        sc->alloc_string_k = next_k;
        return(result);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x7, %rsi
movq %rsi, %r14
andq $-0x8, %r14
movq 0x8c8(%rdi), %rax
leaq (%rax,%r14), %rdx
cmpq $0x10000, %rdx          # imm = 0x10000
jbe 0xd3ef
cmpq $0x200, %rsi            # imm = 0x200
jb 0xd3f8
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8480
movq 0x8d0(%rbx), %rcx
jmp 0xd411
movl $0x10000, %edi          # imm = 0x10000
callq 0x8480
movq %rax, %rcx
movq %rax, 0x8d0(%rbx)
xorl %eax, %eax
movq %r14, %rdx
addq %rcx, %rax
movq %rdx, 0x8c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_port_filename
const char *s7_port_filename(s7_scheme *sc, s7_pointer x)
    {
        if (((is_input_port(x)) ||
                    (is_output_port(x))) &&
                (!port_is_closed(x)))
            return(port_filename(x));
        return(NULL);
    }

// Assembly:
movb (%rsi), %al
andb $-0x2, %al
cmpb $0x22, %al
jne 0xd4da
movq 0x8(%rsi), %rax
cmpb $0x0, 0x2(%rax)
je 0xd4dd
xorl %eax, %eax
retq
movq 0x10(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_flush_output_port
void s7_flush_output_port(s7_scheme *sc, s7_pointer p)
    {
        if ((!is_output_port(p)) ||
                (!is_file_port(p)) ||
                (port_is_closed(p)) ||
                (p == sc->F))
            return;

        if (port_file(p))
        {
            if (port_position(p) > 0)
            {
                if (fwrite((void *)(port_data(p)), 1, port_position(p), port_file(p)) != (size_t)port_position(p))
                    s7_warn(sc, 64, "fwrite trouble in flush-output-port\n");
                port_position(p) = 0;
            }
            fflush(port_file(p));
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x22, (%rsi)
jne 0xd5bf
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpl $0x0, 0x4(%rax)
jne 0xd5bf
cmpb $0x0, 0x2(%rax)
jne 0xd5bf
movq %rdi, %r14
cmpq %rbx, 0x120(%rdi)
je 0xd5bf
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xd5bf
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
jle 0xd5b0
movq 0x10(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x8660
cmpq 0x20(%rbx), %rax
je 0xd5a3
leaq 0xc8a8a(%rip), %rdx     # 0xd6020
pushq $0x40
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xd5c7
andq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
movq %rcx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8490
addq $0x8, %rsp
popq %rbx
popq %r14
retq