LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_for_each_symbol_name
bool s7_for_each_symbol_name(s7_scheme *sc, bool (*symbol_func)(const char *symbol_name, void *data), void *data)
    {
        /* this includes the special constants #<unspecified> and so on for simplicity -- are there any others? */
        int32_t i;
        s7_pointer x;

        for (i = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                if (symbol_func(symbol_name(car(x)), data))
                    return(true);

        return((symbol_func("#t", data))             ||
                (symbol_func("#f", data))             ||
                (symbol_func("#<unspecified>", data)) ||
                (symbol_func("#<undefined>", data))   ||
                (symbol_func("#<eof>", data))         ||
                (symbol_func("#true", data))          ||
                (symbol_func("#false", data)));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x7fed, 0x14(%rsp)     # imm = 0x7FED
jge 0xa77b
movq 0x28(%rsp), %rax
movq 0x148(%rax), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0xa769
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x18(%rsp), %rsi
callq *%rax
testb $0x1, %al
jne 0xa74d
jmp 0xa757
movb $0x1, 0x37(%rsp)
jmp 0xa864
jmp 0xa759
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xa717
jmp 0xa76b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa6eb
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rsi
leaq 0x1d8885(%rip), %rdi    # 0x1e3011
callq *%rax
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0xa85a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rsi
leaq 0x1d8fe0(%rip), %rdi    # 0x1e3790
callq *%rax
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0xa85a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rsi
leaq 0x1d9134(%rip), %rdi    # 0x1e3908
callq *%rax
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0xa85a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rsi
leaq 0x1d72d8(%rip), %rdi    # 0x1e1acc
callq *%rax
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0xa85a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rsi
leaq 0x1d72c5(%rip), %rdi    # 0x1e1ad9
callq *%rax
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0xa85a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rsi
leaq 0x1d72ac(%rip), %rdi    # 0x1e1ae0
callq *%rax
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0xa85a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rsi
leaq 0x1d7292(%rip), %rdi    # 0x1e1ae6
callq *%rax
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_for_each_symbol
bool s7_for_each_symbol(s7_scheme *sc, bool (*symbol_func)(const char *symbol_name, void *data), void *data)
    {
        int32_t i;
        s7_pointer x;

        for (i = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                if (symbol_func(symbol_name(car(x)), data))
                    return(true);

        return(false);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x7fed, 0x14(%rsp)     # imm = 0x7FED
jge 0xa914
movq 0x28(%rsp), %rax
movq 0x148(%rax), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0xa902
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x18(%rsp), %rsi
callq *%rax
testb $0x1, %al
jne 0xa8e9
jmp 0xa8f0
movb $0x1, 0x37(%rsp)
jmp 0xa919
jmp 0xa8f2
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xa8b3
jmp 0xa904
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa88b
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_gensym
s7_pointer s7_gensym(s7_scheme *sc, const char *prefix)
    {
        block_t *b;
        char *name;
        uint32_t location;
        s7_int len;
        uint64_t hash;
        s7_pointer x;

        len = safe_strlen(prefix) + 32;
        b = mallocate(sc, len);
        name = (char *)block_data(b);
        /* there's no point in heroic efforts here to avoid name collisions -- the user can screw up no matter what we do */
        name[0] = '\0';
        len = catstrs(name, len, "{", (prefix) ? prefix : "", "}-", pos_int_to_str_direct(sc, sc->gensym_counter++), NULL);
        hash = raw_string_hash((const uint8_t *)name, len);
        location = hash % SYMBOL_TABLE_SIZE;
        x = new_symbol(sc, name, len, hash, location);  /* not T_GENSYM -- might be called from outside */
        liberate(sc, b);
        return(x);
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0xa430
addq $0x20, %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xaa80
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movb $0x0, (%rax)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0xa9a2
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xa9b0
leaq 0x1e9b10(%rip), %rax    # 0x1f44b9
movq %rax, 0x10(%rsp)
jmp 0xa9b0
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rcx
movl 0x220(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x220(%rcx)
movl %eax, %eax
movl %eax, %esi
callq 0xae30
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rcx
movq %rax, %r9
leaq 0x1d70f6(%rip), %rdx    # 0x1e1aed
leaq 0x1d70f1(%rip), %r8     # 0x1e1aef
xorl %eax, %eax
movq $0x0, (%rsp)
movb $0x0, %al
callq 0xabd0
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xa540
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl $0x7fed, %ecx           # imm = 0x7FED
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x44(%rsp)
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl 0x44(%rsp), %r8d
callq 0xaec0
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xb230
movq 0x28(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mallocate
static inline block_t *mallocate(s7_scheme *sc, size_t bytes)
    {
        block_t *p;
        if (bytes > 0)
        {
            int32_t index;
            if (bytes <= 8)
                index = 3;
            else
            {
                if (bytes <= 256)
                    index = bits[bytes - 1];
                else
                {
                    if (bytes <= 65536)
                        index = 8 + bits[(bytes - 1) >> 8];
                    else index = TOP_BLOCK_LIST; /* expansion to (1 << 17) made no difference */
                }
            }
            p = sc->block_lists[index];
            if (p)
            {
                sc->block_lists[index] = (block_t *)block_next(p);
                /* block_next(p) = NULL; */
            }
            else
            {
                p = mallocate_block(sc);
                block_data(p) = (void *)alloc_permanent_string(sc, (index < TOP_BLOCK_LIST) ? (size_t)(1 << index) : bytes);
                block_set_index(p, index);
            }
        }
        else p = mallocate_block(sc);
        block_set_size(p, bytes);
        return(p);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jbe 0xaba9
cmpq $0x8, 0x28(%rsp)
ja 0xaaac
movl $0x3, 0x1c(%rsp)
jmp 0xab07
cmpq $0x100, 0x28(%rsp)      # imm = 0x100
ja 0xaad0
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
leaq 0x1d6779(%rip), %rax    # 0x1e1240
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
jmp 0xab05
cmpq $0x10000, 0x28(%rsp)    # imm = 0x10000
ja 0xaafb
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
shrq $0x8, %rcx
leaq 0x1d6751(%rip), %rax    # 0x1e1240
movl (%rax,%rcx,4), %eax
addl $0x8, %eax
movl %eax, 0x1c(%rsp)
jmp 0xab03
movl $0x11, 0x1c(%rsp)
jmp 0xab05
jmp 0xab07
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq 0x838(%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xab43
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq %rdx, 0x838(%rax,%rcx,8)
jmp 0xaba7
movq 0x30(%rsp), %rdi
callq 0x11020
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x11, 0x1c(%rsp)
jge 0xab77
movl 0x1c(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
movq %rax, 0x8(%rsp)
jmp 0xab81
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14930
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0xabb8
movq 0x30(%rsp), %rdi
callq 0x11020
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: catstrs
static size_t catstrs(char *dst, size_t len, ...) /* NULL-terminated arg list */
    {
        const char *s, *dend;
        char *d;
        va_list ap;
        d = dst;
        dend = (const char *)(dst + len);
        while ((*d) && (d < dend)) d++;
        va_start(ap, len);
        for (s = va_arg(ap, const char *); s != NULL; s = va_arg(ap, const char *))
            while ((*s) && (d < dend)) {*d++ = *s++;}
        *d = '\0';
        va_end (ap);
        return(d - dst);
    }

// Assembly:
subq $0xa8, %rsp
testb %al, %al
je 0xac02
movaps %xmm0, -0x20(%rsp)
movaps %xmm1, -0x10(%rsp)
movaps %xmm2, (%rsp)
movaps %xmm3, 0x10(%rsp)
movaps %xmm4, 0x20(%rsp)
movaps %xmm5, 0x30(%rsp)
movaps %xmm6, 0x40(%rsp)
movaps %xmm7, 0x50(%rsp)
movq %r9, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq %rcx, -0x38(%rsp)
movq %rdx, -0x40(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xa0(%rsp), %rax
addq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x51(%rsp)
je 0xac7b
movq 0x80(%rsp), %rax
cmpq 0x88(%rsp), %rax
setb %al
movb %al, -0x51(%rsp)
movb -0x51(%rsp), %al
testb $0x1, %al
jne 0xac85
jmp 0xac9b
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0xac4e
leaq 0x60(%rsp), %rax
leaq -0x50(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0xb0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0x60(%rsp), %rax
movq %rax, -0x60(%rsp)
movl 0x60(%rsp), %eax
movl %eax, -0x58(%rsp)
cmpl $0x28, %eax
ja 0xacf5
movq -0x60(%rsp), %rcx
movl -0x58(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x68(%rsp)
jmp 0xad0e
movq -0x60(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x68(%rsp)
movq -0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x90(%rsp)
cmpq $0x0, 0x90(%rsp)
je 0xadfd
jmp 0xad2f
movq 0x90(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x69(%rsp)
je 0xad5c
movq 0x80(%rsp), %rax
cmpq 0x88(%rsp), %rax
setb %al
movb %al, -0x69(%rsp)
movb -0x69(%rsp), %al
testb $0x1, %al
jne 0xad66
jmp 0xad9a
movq 0x90(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rsp)
movb (%rax), %cl
movq 0x80(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x80(%rsp)
movb %cl, (%rax)
jmp 0xad2f
jmp 0xad9c
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movl 0x60(%rsp), %eax
movl %eax, -0x70(%rsp)
cmpl $0x28, %eax
ja 0xadcf
movq -0x78(%rsp), %rcx
movl -0x70(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x80(%rsp)
jmp 0xade8
movq -0x78(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x80(%rsp)
movq -0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x90(%rsp)
jmp 0xad1e
movq 0x80(%rsp), %rax
movb $0x0, (%rax)
movq 0x80(%rsp), %rax
movq 0xa0(%rsp), %rcx
subq %rcx, %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: pos_int_to_str_direct
static char *pos_int_to_str_direct(s7_scheme *sc, s7_int num)
    {
        char *p;
        p = (char *)(sc->int_to_str4 + INT_TO_STR_SIZE - 1);
        *p-- = '\0';
        do {*p-- = "0123456789"[num % 10]; num /= 10;} while (num);
        return((char *)(p + 1));
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
addq $0xb50, %rax            # imm = 0xB50
addq $0x20, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rsp)
movb $0x0, (%rax)
movq -0x10(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
leaq 0x1e3199(%rip), %rax    # 0x1ee015
movb (%rax,%rdx), %cl
movq -0x18(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xae66
movq -0x18(%rsp), %rax
addq $0x1, %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: liberate
static inline void liberate(s7_scheme *sc, block_t *p)
    {
        if (block_index(p) != TOP_BLOCK_LIST)
        {
            block_next(p) = (struct block_t *)sc->block_lists[block_index(p)];
            sc->block_lists[block_index(p)] = p;
        }
        else
        {
            if (block_data(p))
            {
#if S7_DEBUGGING
                permanent_string_len -= block_size(p);
#endif
                free(block_data(p));
                block_data(p) = NULL;
            }
            block_set_index(p, BLOCK_LIST);
            block_next(p) = (struct block_t *)sc->block_lists[block_index(p)];
            sc->block_lists[block_index(p)] = p;
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x11, 0x8(%rax)
je 0xb285
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq 0x838(%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, 0x838(%rax,%rcx,8)
jmp 0xb2ef
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0xb2a9
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x9050
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq 0x838(%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, 0x838(%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_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xfc80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0xb3df
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xb3f0
movq 0x18(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: wrap_string
static s7_pointer wrap_string(s7_scheme *sc, const char *str, s7_int len)
#endif
        {
            s7_pointer x;
            x = sc->string_wrappers[sc->string_wrapper_pos];
            sc->string_wrapper_pos = (sc->string_wrapper_pos + 1) & (NUM_STRING_WRAPPERS - 1); /* i.e. next is pos+1 modulo len */
            string_value(x) = (char *)str;
            string_length(x) = len;
            return(x);
        }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x820(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x7dc(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movl 0x7dc(%rax), %ecx
addl $0x1, %ecx
andl $0x7, %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x7dc(%rax)
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xbbd0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xbbd0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xba0c
movq (%rsp), %rax
movq (%rax), %rax
andq $0x2000000, %rax        # imm = 0x2000000
cmpq $0x0, %rax
jne 0xba0c
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x158(%rcx), %rax
je 0xba0c
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xba0a
movq (%rsp), %rax
movq (%rax), %rax
andq $0x2000000, %rax        # imm = 0x2000000
cmpq $0x0, %rax
jne 0xba0a
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x158(%rcx), %rax
je 0xba0a
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xc0af0
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xba08
movq (%rsp), %rax
movq (%rax), %rax
andq $0x2000000, %rax        # imm = 0x2000000
cmpq $0x0, %rax
jne 0xba08
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x158(%rcx), %rax
je 0xba08
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xc0af0
jmp 0xba0a
jmp 0xba0c
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x28(%rsp), %rax
jne 0xbae2
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0xbae2
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x200(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xb830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x45890
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_slot
static s7_pointer make_permanent_slot(s7_scheme *sc, s7_pointer symbol, s7_pointer value)
    {
        s7_pointer x;
        x = alloc_pointer(sc);
#if S7_DEBUGGING
        permanent_slots++;
#endif
        set_type(x, T_SLOT | T_UNHEAP);
        slot_set_symbol(x, symbol);
        slot_set_value(x, value);
        return(x);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x148a0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movabsq $0x4000000000000020, %rcx # imm = 0x4000000000000020
movq %rcx, (%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), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xaa80
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xbbb0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x93e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_slot_1
static s7_pointer make_slot_1(s7_scheme *sc, s7_pointer env, s7_pointer symbol, s7_pointer value)
    {
        /* env is not rootlet and is a let */
        s7_pointer slot;
        new_cell(sc, slot, T_SLOT);
        slot_set_symbol(slot, symbol);
        slot_set_value(slot, value);
        slot_set_next(slot, let_slots(env));
        let_set_slots(env, slot);
        set_local(symbol);
        /* this is called by varlet so we have to be careful about the resultant let_id
         *   check for greater to ensure shadowing stays in effect, and equal to do updates (set! in effect)
         */
        if (let_id(env) >= symbol_id(symbol))
            symbol_set_local(symbol, let_id(env), slot);
        return(slot);
    }

// 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 0xbefc
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 $0x20, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
orq $0x100000, %rcx         # imm = 0x100000
andq $-0x12201, %rcx         # imm = 0xFFFEDDFF
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jl 0xbfc4
jmp 0xbf95
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0xbfc4
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x1ee0(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq 0x140(%rcx), %rax
jne 0xc614
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xde200
movq %rax, 0x8(%rsp)
jmp 0xc61e
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x1940(%rax), %rsi
movq 0x40(%rsp), %rax
movq 0x1ee0(%rax), %rdx
callq 0x2f940
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: try_to_call_gc
static void try_to_call_gc(s7_scheme *sc)
#endif
        {
            /* called only from new_cell */
            if (sc->gc_off)
            {
                /* we can't just return here!  Someone needs a new cell, and once the heap free list is exhausted, segfault */
                resize_heap(sc);
            }
            else
            {
#if (!S7_DEBUGGING)
                int64_t freed_heap;
                freed_heap = gc(sc);
                if (freed_heap < (sc->heap_size * GC_FRACTION))
                    resize_heap(sc);
#else
                gc(sc, func, line);
                if ((int64_t)(sc->free_heap_top - sc->free_heap) < (sc->heap_size * GC_FRACTION))
                    resize_heap(sc);
#endif
            }
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x218(%rax)
je 0xc697
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc0f40
jmp 0xc6dd
movq 0x10(%rsp), %rdi
callq 0xc1d50
movq %rax, 0x8(%rsp)
cvtsi2sdq 0x8(%rsp), %xmm1
movq 0x10(%rsp), %rax
cvtsi2sdq 0xa8(%rax), %xmm0
movsd 0x1d5295(%rip), %xmm2   # 0x1e1958
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xc6db
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc0f40
jmp 0xc6dd
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: cons_unchecked
static s7_pointer cons_unchecked(s7_scheme *sc, s7_pointer a, s7_pointer b)
    {
        /* apparently slightly faster as a function? */
        s7_pointer x;
        new_cell_no_check(sc, x, T_PAIR | T_SAFE_PROCEDURE);
        set_car(x, a);
        set_cdr(x, b);
        return(x);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_function
s7_pointer s7_apply_function(s7_scheme *sc, s7_pointer fnc, s7_pointer args)
                {
                    TRACK(sc);
#if S7_DEBUGGING
                    {
                        s7_pointer p;
                        int32_t argnum;
                        T_Pos(fnc);       /* not T_App here: (length (openlet (inlet 'length 8))) should raise an error */
                        for (argnum = 0, p = T_Pos(args); is_pair(p); argnum++, p = T_Pos(cdr(p)))
                            T_Pos(car(p));
                    }
#endif

                    set_current_code(sc, history_cons(sc, fnc, args));
                    if (is_c_function(fnc))
                        return(c_function_call(fnc)(sc, args));

                    push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                    sc->code = fnc;
                    sc->args = (needs_copied_args(sc->code)) ? copy_list(sc, args) : args;
                    eval(sc, OP_APPLY);
                    /* we're limited in choices here -- the caller might be (say) car(sc->t1_1) = c_call(...) where the c_call
                     *   happens to fallback on a method -- we can't just push OP_APPLY and drop back into the evaluator normally.
                     */
                    return(sc->value);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xda9d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0xdb6e
jmp 0xda9f
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1df, %ecx            # imm = 0x1DF
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0x10000000, %rax       # imm = 0x10000000
cmpq $0x0, %rax
je 0xdb3b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x44270
movq %rax, (%rsp)
jmp 0xdb44
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x163d0
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1, %ecx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x1228(%rax), %rdx
callq 0x98d0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xc5860
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: set_elist_3
static s7_pointer set_elist_3(s7_scheme *sc, s7_pointer x1, s7_pointer x2, s7_pointer x3)
    {
        s7_pointer p;
        p = sc->elist_3;
        set_car(p, x1); p = cdr(p);
        set_car(p, x2); p = cdr(p);
        set_car(p, x3);
        return(sc->elist_3);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq 0x6e8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x6e8(%rax), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1, %ecx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x1238(%rax), %rdx
callq 0x98d0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xc58b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xfb91
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jle 0xfb91
movq 0x10(%rsp), %rax
movq 0x250(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x250(%rax)
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xfba0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: update_symbol_ids
static void update_symbol_ids(s7_scheme *sc, s7_pointer e)
    {
        s7_pointer p;
        for (p = let_slots(e); tis_slot(p); p = next_slot(p))
        {
            s7_pointer sym;
            sym = slot_symbol(p);
            if (symbol_id(sym) != sc->let_number)
                symbol_set_local(sym, sc->let_number, p);
        }
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xfc2c
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq 0x250(%rcx), %rax
je 0xfc1a
jmp 0xfbe7
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq 0x250(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0xfc1a
jmp 0xfc1c
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xfbb8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0xfcb5
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xfd80
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jge 0xfce9
jmp 0xfcd9
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xfcc3
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0xfd0d
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xfd80
jmp 0xfd0f
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xfd72
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0xfd60
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0xfd4e
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xfd80
jmp 0xfd50
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0xfd2a
jmp 0xfd62
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xfd0f
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -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_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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xfc80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x10012
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%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_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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa4a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10074
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xfc80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x10079
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x100ce
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x150(%rcx), %rax
jne 0x100df
movq 0x20(%rsp), %rax
movq 0x158(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x101d0
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x10149
jmp 0x10105
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x200(%rax), %rsi
callq 0xba20
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x10138
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xba60
jmp 0x10145
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x10147
jmp 0x101c4
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0xb450
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x158(%rcx), %rax
jne 0x101c2
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x101c2
jmp 0x10188
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x100000, %rax         # imm = 0x100000
cmpq $0x0, %rax
jne 0x101ae
movq 0x10(%rsp), %rax
movq (%rax), %rcx
orq $0x10000, %rcx          # imm = 0x10000
movq %rcx, (%rax)
jmp 0x101b0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x101c4
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: symbol_to_local_slot
static s7_pointer symbol_to_local_slot(s7_scheme *sc, s7_pointer symbol, s7_pointer e)
    {
        if (!is_let(e))
            return(global_slot(symbol));

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

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0x101fc
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1025f
movq -0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1024e
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0x1024c
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x1023a
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1025f
jmp 0x1023c
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x10216
jmp 0x1024e
movq -0x10(%rsp), %rax
movq 0x128(%rax), %rax
movq %rax, -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_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:
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 0x10270
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 (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb400
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x10090
movq 0x8(%rsp), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x6(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop