LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_symbol_value
s7_pointer s7_symbol_value(s7_scheme *sc, s7_pointer sym)
    {
        s7_pointer x;
        x = symbol_to_slot(sc, sym);
        if (is_slot(x))
            return(slot_value(x));
        return(sc->undefined);
    }

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rsi), %rdx
movl $0x18, %eax
cmpq %rdx, %r8
je 0x9abd
jle 0x9ab8
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0x9aab
cmpq %rdx, %r8
jne 0x9ad7
movq (%rsi,%rax), %rdx
leaq 0x10(%rdx), %rax
addq $0x128, %rdi            # imm = 0x128
cmpb $0x20, (%rdx)
cmoveq %rax, %rdi
movq (%rdi), %rax
retq
movl $0x10, %eax
cmpb $0x1c, (%rcx)
jne 0x9abd
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x9af6
cmpq %rsi, 0x8(%rdx)
je 0x9ac1
movq 0x18(%rdx), %rdx
jmp 0x9ae5
movq 0x10(%rcx), %rcx
jmp 0x9adc
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: remove_function_from_heap
static void remove_function_from_heap(s7_scheme *sc, s7_pointer value)
    {
        s7_pointer lt;

        s7_remove_from_heap(sc, closure_args(value));
        s7_remove_from_heap(sc, closure_body(value));

        /* remove closure if it's local to current func (meaning (define f (let ...) (lambda ...)) removes the enclosing let) */
        lt = closure_let(value); /* closure_let and all its outlets can't be rootlet */
        if ((is_let(lt)) && (!let_removed(lt)) && (lt != sc->shadow_rootlet))
        {
            lt = outlet(lt);
            if ((is_let(lt)) && (!let_removed(lt)) && (lt != sc->shadow_rootlet))
            {
                remove_let_from_heap(sc, lt);
                lt = outlet(lt);
                if ((is_let(lt)) && (!let_removed(lt)) && (lt != sc->shadow_rootlet))
                    remove_let_from_heap(sc, lt);
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0xa04c
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0xa04c
movq 0x18(%r14), %rax
cmpb $0x1c, (%rax)
jne 0x9f68
testb $0x2, 0x3(%rax)
jne 0x9f68
movq 0x158(%rbx), %rcx
cmpq %rcx, %rax
je 0x9f68
movq 0x10(%rax), %r14
cmpb $0x1c, (%r14)
jne 0x9f68
cmpq %rcx, %r14
je 0x9f68
movq (%r14), %rax
andl $0x2000000, %eax        # imm = 0x2000000
jne 0x9f68
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8c1aa
movq 0x10(%r14), %rsi
cmpb $0x1c, (%rsi)
jne 0x9f68
testb $0x2, 0x3(%rsi)
jne 0x9f68
cmpq 0x158(%rbx), %rsi
je 0x9f68
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8c1aa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: slot_set_value_with_hook_1
static void slot_set_value_with_hook_1(s7_scheme *sc, s7_pointer slot, s7_pointer value)
    {
        /* (set! (hook-functions *rootlet-redefinition-hook*) (list (lambda (hook) (format *stderr* "~A ~A~%" (hook 'symbol) (hook 'value))))) */
        s7_pointer symbol;
        symbol = slot_symbol(slot);
        if ((global_slot(symbol) == slot) &&
                (value != slot_value(slot)))
            s7_call(sc, sc->rootlet_redefinition_hook, set_elist_2(sc, symbol, value));
        slot_set_value(slot, value);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
cmpq %rsi, 0x10(%rax)
jne 0x9fca
cmpq %rbx, 0x10(%r14)
je 0x9fca
movq 0x200(%rdi), %rsi
movq 0x6e0(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x6e0(%rdi), %rdx
callq 0x43bf0
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: reallocate
static block_t *reallocate(s7_scheme *sc, block_t *op, size_t bytes)
    {
        block_t *np;
        np = mallocate(sc, bytes);
        if (block_data(op))  /* presumably block_data(np) is not null */
            memcpy((uint8_t *)(block_data(np)), (uint8_t *)(block_data(op)), block_size(op));
        liberate(sc, op);
        return(np);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x9357
movq %rax, %r15
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xa000
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
callq 0x83e0
movslq 0x8(%rbx), %rax
cmpq $0x11, %rax
jne 0xa02e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa01e
callq 0x8050
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
addq $0x838, %r14            # imm = 0x838
jmp 0xa039
leaq (%r14,%rax,8), %r14
addq $0x838, %r14            # imm = 0x838
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, (%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_varlet
s7_pointer s7_varlet(s7_scheme *sc, s7_pointer env, s7_pointer symbol, s7_pointer value)
    {
        if (!is_let(env))
            return(wrong_type_argument_with_type(sc, sc->varlet_symbol, 1, env, a_let_string));

        if (!is_symbol(symbol))
            return(wrong_type_argument_with_type(sc, sc->varlet_symbol, 2, symbol, a_symbol_string));

        if ((is_slot(global_slot(symbol))) &&
                (is_syntax(slot_value(global_slot(symbol)))))
            return(wrong_type_argument_with_type(sc, sc->varlet_symbol, 2, symbol, wrap_string(sc, "a non-syntactic name", 20)));

        if (env == sc->rootlet)
        {
            if (is_slot(global_slot(symbol)))
                slot_set_value(global_slot(symbol), value);
            else s7_make_slot(sc, env, symbol, value);
        }
        else make_slot_1(sc, env, symbol, value);
        return(value);
    }

// Assembly:
pushq %rbx
movq %rsi, %rax
cmpb $0x1c, (%rsi)
jne 0xa461
movq %rcx, %rbx
movq %rdx, %rcx
cmpb $0xa, (%rdx)
jne 0xa486
movq 0x10(%rcx), %rdx
cmpb $0x20, (%rdx)
jne 0xa4a9
movq 0x10(%rdx), %rsi
cmpb $0x9, (%rsi)
jne 0xa4c2
movq 0x1640(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x13c53a(%rip), %rdx    # 0x146960
movq 0x140(%rdi), %r8
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r10
movq (%rax,%r10,8), %r9
leal 0x1(%r10), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0xffbde(%rip), %rax     # 0x10a031
movq %rax, 0x10(%r9)
movq $0x14, 0x8(%r9)
jmp 0xa4a6
movq 0x1640(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x13c4e5(%rip), %rdx    # 0x146958
movq 0x140(%rdi), %r8
movq 0x1404d7(%rip), %r9     # 0x14a958
movq %rax, %rcx
jmp 0xa4a6
movq 0x1640(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x13c4c8(%rip), %rdx    # 0x146960
movq 0x140(%rdi), %r8
movq 0x1404ba(%rip), %r9     # 0x14a960
popq %rbx
jmp 0xa4e4
cmpq %rax, 0x150(%rdi)
jne 0xa4cb
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0x9c87
jmp 0xa4d9
cmpq %rax, 0x150(%rdi)
je 0xa4de
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0xa332
movq %rbx, %rax
popq %rbx
retq
movq %rbx, 0x10(%rdx)
jmp 0xa4d9
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: wrong_type_arg_error_prepackaged
static s7_pointer wrong_type_arg_error_prepackaged(s7_scheme *sc, s7_pointer caller, s7_pointer arg_n, s7_pointer arg, s7_pointer typnam, s7_pointer descr)
                {
                    /* info list is '(format_string caller arg_n arg type_name descr) */
                    s7_pointer p;
                    p = cdr(sc->wrong_type_arg_info);  /* info list is '(format_string caller arg_n arg type_name descr) */
                    set_car(p, caller);  p = cdr(p);
                    set_car(p, arg_n);   p = cdr(p);
                    set_car(p, arg);     p = cdr(p);
                    set_car(p, (typnam == sc->unused) ? prepackaged_type_name(sc, arg) : typnam);
                    p = cdr(p);
                    set_car(p, descr);
                    return(s7_error(sc, sc->wrong_type_arg_symbol, sc->wrong_type_arg_info));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %rdi, %r14
movq 0x1ee0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %r15
cmpq %r8, 0x140(%rdi)
jne 0xa529
movq %r14, %rdi
movq %rcx, %rsi
callq 0x9c235
movq %rax, %r8
movq %r8, 0x8(%r15)
movq 0x10(%r15), %rax
movq %rbx, 0x8(%rax)
movq 0x1940(%r14), %rsi
movq 0x1ee0(%r14), %rdx
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: call_let_ref_fallback
static s7_pointer call_let_ref_fallback(s7_scheme *sc, s7_pointer env, s7_pointer symbol)
    {
        s7_pointer p;
        /* args could be protected via let = stack_end[1] */
        push_stack_no_let(sc, OP_GC_PROTECT, sc->value, sc->code);
        p = s7_apply_function(sc, find_method(sc, env, sc->let_ref_fallback_symbol), set_qlist_2(sc, env, symbol));
        sc->stack_end -= 4;
        sc->code =  T_Pos(sc->stack_end[0]);
        sc->value =  T_Pos(sc->stack_end[2]);
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x20(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rdi)
movq 0x1228(%rdi), %rdx
callq 0x89ff
movq 0x720(%rbx), %rcx
movq %r15, 0x8(%rcx)
movq 0x720(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, 0x8(%rcx)
movq 0x720(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaee6
movq 0x50(%rbx), %rcx
leaq -0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq -0x20(%rcx), %rdx
movq %rdx, (%rbx)
movq -0x10(%rcx), %rcx
movq %rcx, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: call_let_set_fallback
static s7_pointer call_let_set_fallback(s7_scheme *sc, s7_pointer env, s7_pointer symbol, s7_pointer value)
    {
        s7_pointer p;
        push_stack_no_let(sc, OP_GC_PROTECT, sc->value, sc->code);
        p = s7_apply_function(sc, find_method(sc, env, sc->let_set_fallback_symbol), set_qlist_3(sc, env, symbol, value));
        sc->stack_end -= 4;
        sc->code =  T_Pos(sc->stack_end[0]);
        sc->value =  T_Pos(sc->stack_end[2]);
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x20(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rdi)
movq 0x1238(%rdi), %rdx
callq 0x89ff
movq 0x728(%rbx), %rcx
movq %r12, 0x8(%rcx)
movq 0x728(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r15, 0x8(%rcx)
movq 0x728(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, 0x8(%rcx)
movq 0x728(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaee6
movq 0x50(%rbx), %rcx
leaq -0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq -0x20(%rcx), %rdx
movq %rdx, (%rbx)
movq -0x10(%rcx), %rcx
movq %rcx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
movq 0x8(%rdi), %rax
movq %rsi, 0x8(%rdi)
cmpb $0x1c, (%rsi)
jne 0xbdd9
cmpq $0x0, 0x18(%rsi)
jle 0xbdd9
movq 0x250(%rdi), %rcx
incq %rcx
movq %rcx, 0x250(%rdi)
movq %rcx, 0x18(%rsi)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0xbdd9
movq 0x8(%rcx), %rdx
movq 0x20(%rdx), %rsi
cmpq 0x250(%rdi), %rsi
je 0xbdd3
movq %rcx, 0x18(%rdx)
movq 0x250(%rdi), %rsi
movq %rsi, 0x20(%rdx)
incl 0x28(%rdx)
movq 0x18(%rcx), %rcx
jmp 0xbdab
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18(%rdi), %rdx
movq 0x20(%rsi), %rax
movl $0x18, %ecx
cmpq %rax, %rdx
je 0xbe59
jle 0xbe54
movq 0x10(%rdi), %rdi
movq 0x18(%rdi), %rdx
cmpq %rdx, %rax
jl 0xbe47
cmpq %rax, %rdx
jne 0xbe5e
movq (%rsi,%rcx), %rax
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdi)
jne 0xbe59
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xbe7d
cmpq %rsi, 0x8(%rax)
je 0xbe5d
movq 0x18(%rax), %rax
jmp 0xbe6c
movq 0x10(%rdi), %rdi
jmp 0xbe63
// File: /workspace/github_c_makefile_star2_O3/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 0xbef9
testb $0x1, 0x2(%rsi)
jne 0xbef9
cmpb $0x1c, (%rdx)
jne 0x9a93
movq 0x18(%rdx), %rcx
movq 0x20(%rsi), %rax
cmpq %rax, %rcx
je 0xbed3
jle 0xbece
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rcx
cmpq %rcx, %rax
jl 0xbec1
cmpq %rax, %rcx
jne 0xbed9
movq 0x18(%rsi), %rax
jmp 0xbf02
cmpb $0x1c, (%rdx)
jne 0xbef9
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0xbef3
cmpq %rsi, 0x8(%rax)
je 0xbf02
movq 0x18(%rax), %rax
jmp 0xbee2
movq 0x10(%rdx), %rdx
jmp 0xbed9
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
jne 0xbf07
movq 0x10(%rax), %rax
retq
movq 0x128(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdx, %rax
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rsi), %rdi
movl $0x18, %ecx
cmpq %rdi, %r8
je 0xbf3c
jle 0xbf37
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rdi
jl 0xbf2a
cmpq %rdi, %r8
jne 0xbf4a
movq (%rsi,%rcx), %rdi
cmpb $0x20, (%rdi)
jne 0xbf49
movq %rax, 0x10(%rdi)
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xbf3c
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
je 0xbf69
cmpq %rsi, 0x8(%rdi)
je 0xbf40
movq 0x18(%rdi), %rdi
jmp 0xbf58
movq 0x10(%rdx), %rdx
jmp 0xbf4f
// File: /workspace/github_c_makefile_star2_O3/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 0x8f16
testq %rax, %rax
je 0xbfb3
movq 0x8(%rbx), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0xbfa7
jle 0xbfa2
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0xbf95
cmpq %rsi, %rdi
jne 0xbfb7
movq (%rax,%rcx), %rsi
cmpb $0x20, (%rsi)
sete %al
jmp 0xbfb5
xorl %eax, %eax
popq %rbx
retq
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xbfa7
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0xbfd6
cmpq %rax, 0x8(%rsi)
je 0xbfab
movq 0x18(%rsi), %rsi
jmp 0xbfc5
movq 0x10(%rdx), %rdx
jmp 0xbfbc
// File: /workspace/github_c_makefile_star2_O3/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 0xc003
movq %rsi, %r12
cmpq %rsi, 0x150(%r15)
jne 0xc00a
movq 0x158(%r15), %r12
cmpb $0x1c, (%r12)
jne 0xc02e
cmpq $0x0, 0x20(%rbx)
je 0xc034
movq 0x8(%r12), %r13
testq %r13, %r13
je 0xc034
cmpq %rbx, 0x8(%r13)
je 0xc03e
movq 0x18(%r13), %r13
jmp 0xc01d
leaq 0x10(%rbx), %rax
jmp 0xc03b
leaq 0x128(%r15), %rax
movq (%rax), %r13
cmpb $0x20, (%r13)
jne 0xc07b
movq 0x200(%r15), %rax
movq 0x18e0(%r15), %rsi
movq 0x18(%rax), %rdx
movq %r15, %rdi
callq 0xbe9a
cmpb $0x1, (%rax)
jne 0xc0ba
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9f83
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x9c87
cmpq 0x158(%r15), %r12
jne 0xc0be
movq 0x10(%rbx), %rax
cmpb $0x20, (%rax)
je 0xc0be
movq (%rbx), %rax
btl $0x14, %eax
jb 0xc0b0
orq $0x10000, %rax          # imm = 0x10000
movq %rax, (%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
jmp 0xc0be
movq %r14, 0x10(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: s7_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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x9afc
movq %rax, %r12
movq 0x110(%r15), %rsi
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0xbfdc
movq 0x8(%r12), %rax
orq $0x20000000, (%rax)     # imm = 0x20000000
movq %rbx, %rdi
callq 0xc157
movq 0x8(%r12), %rcx
movq 0x20(%rcx), %rcx
movq %rax, 0x18(%rcx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: copy_string
static inline s7_int safe_strlen(const char *str)
    {
        /* this is safer than strlen, and slightly faster */
        const char *tmp = str;
        if ((!tmp) || (!(*tmp))) return(0);
        for (; *tmp; ++tmp);
        return(tmp - str);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc194
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0xc194
movl $0x1, %edi
cmpb $0x0, (%rbx,%rdi)
leaq 0x1(%rdi), %rdi
jne 0xc16e
leaq -0x1(%rdi), %r14
callq 0x8480
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x83e0
jmp 0xc1a4
movl $0x1, %edi
callq 0x8480
movq %rax, %r15
xorl %r14d, %r14d
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9afc
movq %rax, %r15
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xbfdc
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_O3/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 0xc1b2
movq %rax, %r15
movq 0x8(%rax), %rax
orq $0x20000000, (%rax)     # imm = 0x20000000
movq %rbx, %rdi
callq 0xc157
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_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %rbx
testq %rsi, %rsi
je 0xc283
cmpb $0x0, (%r13)
je 0xc283
xorl %eax, %eax
leaq 0x1(%rax), %r15
cmpb $0x0, 0x1(%r13,%rax)
movq %r15, %rax
jne 0xc272
jmp 0xc286
xorl %r15d, %r15d
leaq 0x2(%r15), %rsi
movq %rbx, %rdi
callq 0x9357
movq %rax, %r14
movq (%rax), %r12
leaq 0x10a584(%rip), %rsi    # 0x116823
movq %r12, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xc442
incq %r15
movq $0x0, 0x8(%rsp)
cmpq $0x8, %r15
jg 0xc32a
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x83e0
movq (%r13), %r13
movabsq $-0x7fecfd2d94c4151b, %rcx # imm = 0x801302D26B3BEAE5
movq %r13, %rax
mulq %rcx
shrq $0xe, %rdx
imulq $0x7fed, %rdx, %rax     # imm = 0x7FED
movq %r13, %rbp
subq %rax, %rbp
movq 0x148(%rbx), %rax
movq 0x10(%rax), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rax
cmpb $0x1, (%rax)
jne 0xc3c5
cmpq 0x18(%rax), %r13
jne 0xc324
movl 0x2c(%rax), %ecx
cmpq %rcx, %r15
je 0xc432
movq 0x10(%rax), %rax
jmp 0xc309
movq %r14, (%rsp)
movq (%r12), %r13
leaq 0x10(%rsp), %rbp
movq $0x0, (%rbp)
leaq 0x8(%r12), %rsi
cmpq $0x10, %r15
movl $0x10, %edx
cmovbq %r15, %rdx
addq $-0x8, %rdx
movq %rbp, %rdi
callq 0x83e0
addq (%rbp), %r13
movabsq $-0x7fecfd2d94c4151b, %rcx # imm = 0x801302D26B3BEAE5
movq %r13, %rax
mulq %rcx
shrq $0xe, %rdx
imulq $0x7fed, %rdx, %rax     # imm = 0x7FED
movq %r13, %rbp
subq %rax, %rbp
movq 0x148(%rbx), %rax
movq 0x10(%rax), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %r14
cmpb $0x1, (%r14)
jne 0xc3c1
cmpq 0x18(%r14), %r13
jne 0xc3bb
movl 0x2c(%r14), %eax
cmpq %rax, %r15
jne 0xc3bb
movq 0x20(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x8c146
testb %al, %al
jne 0xc438
movq 0x10(%r14), %r14
jmp 0xc393
movq (%rsp), %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x9632
movq %rax, %r15
movslq 0x8(%r14), %rax
cmpq $0x11, %rax
jne 0xc40b
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc3fa
callq 0x8050
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
addq $0x838, %rbx            # imm = 0x838
jmp 0xc416
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rax), %r15
jmp 0xc3dc
movq 0x8(%r14), %r15
movq (%rsp), %r14
jmp 0xc3dc
// File: /workspace/github_c_makefile_star2_O3/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 0xc486
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 0xc4f7
movq %rdi, %rax
movb (%rsi), %cl
testb %cl, %cl
je 0xc4c6
incq %rsi
movb %cl, (%rax)
incq %rax
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0xc4b8
movl -0x80(%rsp), %edx
cmpq $0x28, %rdx
ja 0xc4e1
movq %rdx, %rcx
addq -0x70(%rsp), %rcx
addl $0x8, %edx
movl %edx, -0x80(%rsp)
jmp 0xc4ef
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x78(%rsp)
movq (%rcx), %rsi
testq %rsi, %rsi
jne 0xc4af
movb $0x0, (%rax)
subq %rdi, %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc583
movq %r14, %rdi
callq 0xa550
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_O3/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 0xcbbf
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_O3/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 0xd29b
leaq 0x1396bb(%rip), %rax    # 0x146950
movq (%rax,%rbx,8), %rax
jmp 0xd2d7
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xd2bd
movq %r14, %rdi
callq 0xa550
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_O3/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 0xd312
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
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_O3/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 0xd366
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
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_O3/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 0xd3e4
jp 0xd3e4
cmpq %rcx, %rax
ja 0xd3c7
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xa550
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 0xd42e
cmpq %rcx, %rax
ja 0xd40e
movq %rbx, %rdi
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0xa550
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_O3/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 0xd4c4
cmpl $0xc, %eax
je 0xd4b3
cmpl $0xd, %eax
jne 0xd4cb
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 0xfe37e(%rip), %r8      # 0x10b851
movq %rdx, %rsi
xorl %edx, %edx
callq 0xd4e5
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
jle 0xd5c8
testq %rsi, %rsi
je 0xd51c
cmpb $0x0, (%rsi)
je 0xd51c
xorl %ecx, %ecx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rsi,%rcx)
movq %rax, %rcx
jne 0xd50c
jmp 0xd51e
xorl %eax, %eax
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdi
movq (%rcx,%rdi,8), %r12
leal 0x1(%rdi), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
movq %rsi, 0x10(%r12)
movq %rax, 0x8(%r12)
movq 0x1f00(%r14), %rax
movq %rdx, 0x8(%rax)
movq 0x1f00(%r14), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x43731
testq %r15, %r15
je 0xd582
cmpb $0x0, (%r15)
je 0xd582
xorl %edx, %edx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%r15,%rdx)
movq %rcx, %rdx
jne 0xd571
jmp 0xd584
xorl %ecx, %ecx
movq 0x820(%r14), %rdx
movslq 0x7dc(%r14), %rsi
movq (%rdx,%rsi,8), %r9
leal 0x1(%rsi), %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r14)
movq %r15, 0x10(%r9)
movq %rcx, 0x8(%r9)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq %rax, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa4e4
testq %rsi, %rsi
je 0xd5e4
cmpb $0x0, (%rsi)
je 0xd5e4
xorl %ecx, %ecx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rsi,%rcx)
movq %rax, %rcx
jne 0xd5d4
jmp 0xd5e6
xorl %eax, %eax
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %r12
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
movq %rsi, 0x10(%r12)
movq %rax, 0x8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x43731
testq %r15, %r15
je 0xd638
cmpb $0x0, (%r15)
je 0xd638
xorl %edx, %edx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%r15,%rdx)
movq %rcx, %rdx
jne 0xd627
jmp 0xd63a
xorl %ecx, %ecx
movq 0x820(%r14), %rdx
movslq 0x7dc(%r14), %rsi
movq (%rdx,%rsi,8), %r8
leal 0x1(%rsi), %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r14)
movq %r15, 0x10(%r8)
movq %rcx, 0x8(%r8)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %r15, (%rsp)
movl $0x14, %r8d
xorl %ecx, %ecx
movl $0x67, %r9d
callq 0xd7ce
movq %rax, %r14
movq (%rax), %r12
movq (%r15), %r13
leaq 0x1(%r13), %rdi
callq 0x8480
movq %rax, %r15
testq %r13, %r13
je 0xd774
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x83e0
movb $0x0, (%r15,%r13)
movslq 0x8(%r14), %rax
cmpq $0x11, %rax
jne 0xd7a8
testq %r12, %r12
je 0xd797
movq %r12, %rdi
callq 0x8050
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
addq $0x838, %rbx            # imm = 0x838
jmp 0xd7b3
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe121
movq 0x1438(%rbx), %rax
movq 0x8(%rax), %r15
movq 0x138884(%rip), %r14    # 0x146958
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe0fd
movq %rbx, %rdi
movdqa %xmm0, (%rsp)
callq 0xa550
movdqa (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movq %xmm0, 0x8(%rax)
movq 0x13c919(%rip), %rcx    # 0x14aa38
jmp 0xe198
movdqa 0xfbd97(%rip), %xmm1    # 0x109ec0
pand %xmm0, %xmm1
ucomisd 0xf7f0b(%rip), %xmm1    # 0x106040
jbe 0xe1e5
movq 0x1438(%rbx), %rax
movq 0x8(%rax), %r15
movq 0x13880b(%rip), %r14    # 0x146958
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe176
movq %rbx, %rdi
movdqa %xmm0, (%rsp)
callq 0xa550
movdqa (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movq %xmm0, 0x8(%rax)
movq 0x13c8a8(%rip), %rcx    # 0x14aa40
movq 0x1ee8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq %r15, 0x8(%rdx)
movq 0x10(%rdx), %rdx
movq %r14, 0x8(%rdx)
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38dfa
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd 0x258(%rbx), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xcc3d
// File: /workspace/github_c_makefile_star2_O3/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 0xe287
leaq 0xf7f52(%rip), %rcx     # 0x10619c
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_O3/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 0xe543
movq %rsi, %rcx
movq 0x8(%rsi), %r14
cmpb $0x24, (%r14)
je 0xe54a
movq 0x1428(%rbx), %rdx
movq 0x13c527(%rip), %r8     # 0x14aa50
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe659
movq 0xaa0(%rbx), %r14
movq 0x8(%r14), %r13
leaq 0x1383fb(%rip), %r12    # 0x146950
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0xe564
movq (%r12,%r13,8), %r15
jmp 0xe59d
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe583
movq %rbx, %rdi
callq 0xa550
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 0xe5b0
movq (%r12,%r13,8), %r14
jmp 0xe5e9
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xe5cf
movq %rbx, %rdi
callq 0xa550
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 0xe60f
movq %rbx, %rdi
callq 0xa550
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_O3/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 0xe74a
movq %r14, %rdi
callq 0xa550
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_O3/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, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xe8cf
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200013, (%rbx)       # imm = 0x200013
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x9357
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testq %r15, %r15
jle 0xe910
movq %r12, %rsi
movq %r15, %rdx
callq 0x83e0
movq 0x10(%rbx), %rdi
movb $0x0, (%rdi,%r15)
movq %r15, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0xe950
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xeade
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x13, (%rbx)
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x9357
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testb %bpl, %bpl
sete %al
testq %r15, %r15
setle %cl
orb %al, %cl
jne 0xeb59
movzbl %bpl, %esi
cmpq $0x8, %r15
jb 0xeb51
movq %r15, %rax
shrq $0x3, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rsi, %rcx
movq %rcx, (%rdi)
addq $0x8, %rdi
decq %rax
jne 0xeb3a
movq %r15, %rdx
andq $0x7, %rdx
jne 0xeb54
jmp 0xeb59
movq %r15, %rdx
callq 0x8270
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r15)
movq $0x0, 0x18(%rbx)
movq %r15, 0x8(%rbx)
movq 0x738(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0xeb9d
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq