LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x10370
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
orq $0x20000000, %rcx       # imm = 0x20000000
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x10340
movq %rax, %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa430
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x2, %rsi
callq 0xaa80
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x1dde05(%rip), %rsi    # 0x1ee2f8
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x10540
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
addq $0x1, %rdx
callq 0xa2b0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb230
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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 $0x88, %rsp
testb %al, %al
je 0x10572
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 %r9, -0x38(%rsp)
movq %r8, -0x40(%rsp)
movq %rcx, -0x48(%rsp)
movq %rdx, -0x50(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x50(%rsp), %rax
leaq -0x60(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x90(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x78(%rsp), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x10671
jmp 0x105df
movq 0x70(%rsp), %rax
cmpb $0x0, (%rax)
je 0x10611
movq 0x70(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rsp)
movb (%rax), %cl
movq 0x68(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x68(%rsp)
movb %cl, (%rax)
jmp 0x105df
jmp 0x10613
leaq 0x50(%rsp), %rax
movq %rax, -0x70(%rsp)
movl 0x50(%rsp), %eax
movl %eax, -0x64(%rsp)
cmpl $0x28, %eax
ja 0x10646
movq -0x70(%rsp), %rcx
movl -0x64(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x78(%rsp)
jmp 0x1065f
movq -0x70(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x78(%rsp)
movq -0x78(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x105d1
movq 0x68(%rsp), %rax
movb $0x0, (%rax)
movq 0x68(%rsp), %rax
movq 0x80(%rsp), %rcx
subq %rcx, %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_c_pointer
void *s7_c_pointer(s7_pointer p)
    {
        if ((is_number(p)) &&
                (s7_integer(p) == 0))
            return(NULL); /* special case where the null pointer has been cons'd up by hand */

        if (!is_c_pointer(p))
            return(NULL);

        return(c_pointer(p));
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x209d66(%rip), %rax    # 0x21a4a0
testb $0x1, (%rax,%rcx)
je 0x1075b
movq 0x8(%rsp), %rdi
callq 0x10790
cmpq $0x0, %rax
jne 0x1075b
movq $0x0, 0x10(%rsp)
jmp 0x10781
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x21, %eax
je 0x10773
movq $0x0, 0x10(%rsp)
jmp 0x10781
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1080c
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x21, (%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x120(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x120(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x48(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x10af0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x530(%rax)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x10999
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x25, (%rax)
movq 0x20(%rsp), %rdi
callq 0x11020
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rdi
callq 0x11080
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x60(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x1c(%rax)
movq 0x20(%rsp), %rax
movl 0x78(%rax), %ecx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x20(%rax)
movq 0x20(%rsp), %rdi
callq 0x11130
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x24(%rax)
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x530(%rax)
movq 0x20(%rsp), %rax
movq 0x760(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x11230
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x838(%rax)
jne 0x11042
movq 0x10(%rsp), %rdi
callq 0xc6650
movq 0x10(%rsp), %rax
movq 0x838(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x838(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: copy_op_stack
static s7_pointer copy_op_stack(s7_scheme *sc)
    {
        s7_pointer nv;
        int32_t len;

        len = (int32_t)(sc->op_stack_now - sc->op_stack);
        nv = make_simple_vector(sc, len); /* not sc->op_stack_size */
        if (len > 0)
        {
            int32_t i;
            s7_pointer *src, *dst;
            src = sc->op_stack;
            dst = (s7_pointer *)vector_elements(nv);
            for (i = len; i > 0; i--) *dst++ = *src++;
        }
        return(nv);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x60(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x34da0
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x11120
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0x1111e
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
movq (%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, (%rsp)
movq %rcx, (%rax)
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x110e4
jmp 0x11120
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: find_any_baffle
static s7_int find_any_baffle(s7_scheme *sc)
    {
        /* search backwards through sc->envir for any sc->baffle_symbol */
        if (sc->baffle_ctr > 0)
        {
            s7_pointer x, y;
            for (x = sc->envir; is_let(x); x = outlet(x))
                for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                    if (slot_symbol(y) == sc->baffle_symbol)
                        return(baffle_key(slot_value(y)));

            if ((is_slot(global_slot(sc->baffle_symbol))) &&
                    (is_baffle(slot_value(global_slot(sc->baffle_symbol)))))
                return(baffle_key(slot_value(global_slot(sc->baffle_symbol))));
        }
        return(-1);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0xa98(%rax)
jle 0x11220
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x111cb
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x111b9
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x17d8(%rcx), %rax
jne 0x111a7
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x11229
jmp 0x111a9
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x11171
jmp 0x111bb
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x11156
movq -0x10(%rsp), %rax
movq 0x17d8(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x1121e
movq -0x10(%rsp), %rax
movq 0x17d8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x27, %eax
jne 0x1121e
movq -0x10(%rsp), %rax
movq 0x17d8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x11229
jmp 0x11220
movq $-0x1, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x11287
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x9510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x10(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x114e0
testb $0x1, %al
jne 0x11428
jmp 0x11446
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x11a80
movq %rax, 0x40(%rsp)
jmp 0x114c7
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x11476
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xd, (%rax)
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x12126
movq 0x10(%rsp), %rcx
leaq 0x204365(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0x12193
jmp 0x12128
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1214c
movq 0x18(%rsp), %rdi
callq 0xc670
movq 0x18(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0xb, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1232d
jp 0x1232d
jmp 0x122c8
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x122ec
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0xd, (%rax)
movsd 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x123a2
jmp 0x1232f
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x12353
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0xe, (%rax)
movsd 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x12495
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x1252d
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x4(%rsp)
subl $0xb, %eax
je 0x124be
jmp 0x124a8
movl 0x4(%rsp), %eax
subl $0xc, %eax
je 0x124d1
jmp 0x124b3
movl 0x4(%rsp), %eax
subl $0xd, %eax
je 0x124f3
jmp 0x12505
movq 0x10(%rsp), %rax
cvtsi2sdq 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x1252d
movq 0x10(%rsp), %rax
cvtsi2sdq 0x8(%rax), %xmm0
movq 0x10(%rsp), %rax
cvtsi2sdq 0x10(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x1252d
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x1252d
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x1d0e07(%rip), %r8     # 0x1e3326
callq 0x12540
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movq %r8, 0x88(%rsp)
cmpq $0x0, 0x98(%rsp)
jle 0x12677
movq 0xa8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xa430
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq %rax, %rdx
callq 0xb880
movq %rax, 0x68(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x12430
movq %rax, 0x70(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x44fe0
movq %rax, 0x80(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x88(%rsp), %rdi
callq 0xa430
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq %rax, %rdx
callq 0xb880
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %r8
movq %rax, %r9
callq 0xc560
movq %rax, 0xb0(%rsp)
jmp 0x12744
movq 0xa8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, (%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xa430
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xb880
movq %rax, 0x28(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x44fe0
movq %rax, 0x38(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rdi
callq 0xa430
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0xb880
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq %rax, %r8
callq 0x14a60
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_number_to_integer_with_caller
s7_int s7_number_to_integer_with_caller(s7_scheme *sc, s7_pointer x, const char *caller)
    {
        if (is_t_integer(x))
            return(integer(x));

#if WITH_GMP
        if (is_t_big_integer(x))
            return(big_integer_to_s7_int(big_integer(x)));
#endif
        s7_wrong_type_arg_error(sc, caller, 0, x, "an integer");
        return(0);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x127c0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x127e8
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x1dc458(%rip), %r8     # 0x1eec32
callq 0x12540
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_numerator
s7_int s7_numerator(s7_pointer x)
    {
        switch (type(x))
        {
            case T_INTEGER:     return(integer(x));
            case T_RATIO:       return(numerator(x));
#if WITH_GMP
            case T_BIG_INTEGER: return(big_integer_to_s7_int(big_integer(x)));
            case T_BIG_RATIO:   return(big_integer_to_s7_int(mpq_numref(big_ratio(x))));
#endif
        }
        return(0);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rsp)
subl $0xb, %eax
je 0x12853
jmp 0x12848
movl -0x14(%rsp), %eax
subl $0xc, %eax
je 0x12863
jmp 0x12873
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1287c
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1287c
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x14, %r8d
movl $0x67, %r9d
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x129b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x135a0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
callq 0x9480
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x135db
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x93e0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x13860
testb $0x1, %al
jne 0x1366c
movsd 0x60(%rsp), %xmm1
movaps %xmm1, %xmm0
movaps 0x1ce472(%rip), %xmm2   # 0x1e1aa0
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x1ce320(%rip), %xmm1   # 0x1e1970
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x1373a
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq 0x1438(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x202df6(%rip), %rax    # 0x216488
movq %rax, 0x28(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x136c7
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq $0xd, (%rax)
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdi
movsd 0x50(%rsp), %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rcx
movq 0x206e3d(%rip), %r8     # 0x21a568
callq 0x13880
movq %rax, 0x70(%rsp)
jmp 0x1384d
movsd 0x60(%rsp), %xmm0
movsd 0x1ce238(%rip), %xmm1   # 0x1e1980
ucomisd %xmm1, %xmm0
ja 0x13762
movsd 0x1ce232(%rip), %xmm0   # 0x1e1988
ucomisd 0x60(%rsp), %xmm0
jbe 0x1382b
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rax
movq 0x1438(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x202d01(%rip), %rax    # 0x216488
movq %rax, 0x10(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x137bc
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq $0xd, (%rax)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movq 0x206d51(%rip), %r8     # 0x21a570
callq 0x13880
movq %rax, 0x70(%rsp)
jmp 0x1384d
movq 0x68(%rsp), %rdi
movsd 0x60(%rsp), %xmm0
movq 0x68(%rsp), %rax
movsd 0x258(%rax), %xmm1
callq 0x113e0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
addl $-0xb, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rsp)
subl $0x3, %eax
ja 0x1398b
movq -0x30(%rsp), %rax
leaq 0x1c983c(%rip), %rcx    # 0x1dd154
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rsp), %rax
cvtsi2sdq 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x13994
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, -0x18(%rsp)
fildll -0x18(%rsp)
movq %rax, -0x20(%rsp)
fildll -0x20(%rsp)
fdivrp %st, %st(1)
fstpl -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x13994
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x13994
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x13994
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x142e7
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x24, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0xaa0(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x14507
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x200013, (%rax)       # imm = 0x200013
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0xaa80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rsp)
jle 0x1458a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x93e0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x738(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11230
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x146d8
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x13, (%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
callq 0xaa80
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movsbl 0x17(%rsp), %eax
cmpl $0x0, %eax
je 0x14767
cmpq $0x0, 0x18(%rsp)
jle 0x14767
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movb 0x17(%rsp), %al
movq 0x18(%rsp), %rdx
movzbl %al, %esi
callq 0xc85e0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x738(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x11230
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x148a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movabsq $0x4000000001000013, %rcx # imm = 0x4000000001000013
movq %rcx, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0x1486c
movq 0x18(%rsp), %rdi
callq 0xa430
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0x14930
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x93e0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x14886
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x100, 0x7f0(%rax)     # imm = 0x100
jne 0x148f6
movq (%rsp), %rax
movl 0x7d8(%rax), %ecx
addl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x7d8(%rax)
movl $0x100, %edi            # imm = 0x100
movl $0x30, %esi
callq 0x9360
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x800(%rax)
movq (%rsp), %rax
movl $0x0, 0x7f0(%rax)
movq (%rsp), %rax
movq 0x800(%rax), %rax
movq (%rsp), %rdx
movl 0x7f0(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x7f0(%rdx)
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x8c8(%rax), %rax
addq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x10000, (%rsp)        # imm = 0x10000
jbe 0x149bd
cmpq $0x200, 0x10(%rsp)      # imm = 0x200
jb 0x1498b
movq 0x10(%rsp), %rdi
callq 0x9480
movq %rax, 0x20(%rsp)
jmp 0x149f4
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8d0(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x8c8(%rax)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x8d0(%rax), %rax
movq 0x18(%rsp), %rcx
addq 0x8c8(%rcx), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8c8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x14b44
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x14b67
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x14b67
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x14b70
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x14d5c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x14d5c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x14d5c
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x14d61
jmp 0x14de8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x14de8
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jle 0x14dd6
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x9660
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0x14dc9
movq 0x10(%rsp), %rdi
movl $0x40, %esi
leaq 0x1ccda6(%rip), %rdx    # 0x1e1b68
movb $0x0, %al
callq 0x14df0
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x9490
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_warn
static void s7_warn(s7_scheme *sc, s7_int len, const char *ctrl, ...) /* len = max size of output string (for vsnprintf) */
                {
                    if (sc->error_port != sc->F)
                    {
                        va_list ap;
                        s7_pointer warning;
                        char *str;

                        warning = make_empty_string(sc, len, 0);
                        string_value(warning)[0] = '\0';
                        str = (char *)string_value(warning);
                        va_start(ap, ctrl);
                        vsnprintf(str, len, ctrl, ap);
                        va_end(ap);

                        if (port_is_closed(sc->error_port))
                            sc->error_port = sc->standard_error;
                        s7_display(sc, warning, sc->error_port);
                    }
                }

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x14e2c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq 0x190(%rax), %rax
movq 0xf0(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x14f69
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
xorl %edx, %edx
callq 0x146a0
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0xb8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb0(%rsp)
leaq 0xc0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0xb0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0x9130
leaq 0xc0(%rsp), %rax
movq 0xf0(%rsp), %rax
movq 0x190(%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x14f45
movq 0xf0(%rsp), %rax
movq 0x1d8(%rax), %rcx
movq 0xf0(%rsp), %rax
movq %rcx, 0x190(%rax)
movq 0xf0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xf0(%rsp), %rax
movq 0x190(%rax), %rdx
callq 0x2d460
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)