LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: find_method
static s7_pointer find_method(s7_scheme *sc, s7_pointer env, s7_pointer symbol)
    {
        s7_pointer x;
        if (symbol_id(symbol) == 0) /* this means the symbol has never been used locally, so how can it be a method? */
            return(sc->undefined);

        if (let_id(env) == symbol_id(symbol))
            return(slot_value(local_slot(symbol)));

        for (x = env; symbol_id(symbol) < let_id(x); x = outlet(x));

        if (let_id(x) == symbol_id(symbol))
            return(slot_value(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(slot_value(y));
        }
        return(sc->undefined);
    }

// Assembly:
movq 0x20(%rdx), %rax
testq %rax, %rax
je 0x9a4a
cmpq %rax, 0x18(%rsi)
je 0x9a12
movq 0x18(%rsi), %rcx
cmpq %rcx, %rax
jge 0x9a0d
movq 0x10(%rsi), %rsi
jmp 0x99fe
cmpq %rax, %rcx
jne 0x9a1c
movq 0x18(%rdx), %rdi
addq $0x10, %rdi
jmp 0x9a51
cmpb $0x1c, (%rsi)
jne 0x9a4a
movq 0x8(%rsi), %r8
testq %r8, %r8
sete %cl
je 0x9a3d
cmpq %rdx, 0x8(%r8)
je 0x9a39
movq 0x18(%r8), %r8
jmp 0x9a25
movq 0x10(%r8), %rax
testb %cl, %cl
je 0x9a54
movq 0x10(%rsi), %rsi
cmpb $0x1c, (%rsi)
je 0x9a21
addq $0x128, %rdi            # imm = 0x128
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: find_let
static s7_pointer find_let(s7_scheme *sc, s7_pointer obj)
    {
        if (is_let(obj)) return(obj);
        switch (type(obj))
        {
            case T_MACRO:   case T_MACRO_STAR:
            case T_BACRO:   case T_BACRO_STAR:
            case T_CLOSURE: case T_CLOSURE_STAR:
                return(closure_let(obj));

            case T_C_OBJECT:
                return(c_object_let(obj));

            case T_C_POINTER:
                if ((is_let(c_pointer_info(obj))) &&
                        (c_pointer_info(obj) != sc->rootlet))
                    return(c_pointer_info(obj));
        }
        return(sc->nil);
    }

// Assembly:
movq %rsi, %rax
movzbl (%rsi), %ecx
cmpl $0x27, %ecx
jle 0x9a73
addl $-0x28, %ecx
cmpl $0x5, %ecx
ja 0x9a94
addq $0x18, %rax
movq %rax, %rdi
movq (%rdi), %rax
retq
cmpl $0x14, %ecx
je 0x9a68
cmpl $0x1c, %ecx
je 0x9a72
cmpl $0x21, %ecx
jne 0x9a94
movq 0x18(%rax), %rax
cmpb $0x1c, (%rax)
jne 0x9a94
cmpq 0x150(%rdi), %rax
jne 0x9a72
addq $0x110, %rdi            # imm = 0x110
jmp 0x9a6f
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_protect
s7_inline s7_int s7_gc_protect(s7_scheme *sc, s7_pointer x)
    {
        s7_int loc;
        if (sc->gpofl_loc < 0)
            resize_gc_protect(sc);
        loc = sc->gpofl[sc->gpofl_loc--];
        vector_element(sc->protected_objects, loc) = x;
        return(loc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x108(%rdi)
jns 0x9be2
movq 0xd0(%r14), %rax
movq 0xf0(%r14), %r12
leaq (%r12,%r12), %r13
movq 0x18(%rax), %rsi
movq %r12, %r15
shlq $0x4, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0xae0f
movq $0x0, 0x20(%rax)
movq 0xd0(%r14), %rcx
movq %rax, 0x18(%rcx)
movq (%rax), %rax
movq 0xd0(%r14), %rcx
movq %rax, 0x10(%rcx)
movq 0xd0(%r14), %rax
movq %r13, 0x8(%rax)
movq %r13, 0xf0(%r14)
movq 0xe8(%r14), %rdi
movq %r15, %rsi
callq 0x9510
movq %rax, 0xe8(%r14)
cmpq %r13, %r12
jge 0x9be2
movq %r12, %rax
movq 0xd0(%r14), %rcx
movq 0x140(%r14), %rdx
movq 0x10(%rcx), %rcx
movq %rdx, (%rcx,%rax,8)
movq 0xe8(%r14), %rcx
movq 0x108(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x108(%r14)
movq %rax, 0x8(%rcx,%rdx,8)
incq %rax
decq %r12
jne 0x9ba6
movq 0xd0(%r14), %rcx
movq 0xe8(%r14), %rax
movq 0x108(%r14), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, 0x108(%r14)
movq (%rax,%rdx,8), %rax
movq 0x10(%rcx), %rcx
movq %rbx, (%rcx,%rax,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_unprotect
void s7_gc_unprotect(s7_scheme *sc, s7_pointer x)
    {
        s7_int i;
        for (i = 0; i < sc->protected_objects_size; i++)
            if (vector_element(sc->protected_objects, i) == x)
            {
                vector_element(sc->protected_objects, i) = sc->unused;
                sc->gpofl[++sc->gpofl_loc] = i;
                return;
            }
    }

// Assembly:
movq 0xf0(%rdi), %rcx
testq %rcx, %rcx
jle 0x9c3f
movq 0xd0(%rdi), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
cmpq %rsi, (%rdx,%rax,8)
je 0x9c40
incq %rax
cmpq %rax, %rcx
jne 0x9c31
retq
movq 0x140(%rdi), %rcx
movq %rcx, (%rdx,%rax,8)
movq 0xe8(%rdi), %rcx
movq 0x108(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x108(%rdi)
movq %rax, 0x8(%rcx,%rdx,8)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_unprotect_at
void s7_gc_unprotect_at(s7_scheme *sc, s7_int loc)
    {
        if (loc < sc->protected_objects_size)
        {
            if (vector_element(sc->protected_objects, loc) != sc->unused)
                sc->gpofl[++sc->gpofl_loc] = loc;
            vector_element(sc->protected_objects, loc) = sc->unused;
        }
    }

// Assembly:
cmpq %rsi, 0xf0(%rdi)
jle 0x9cb1
movq 0xd0(%rdi), %rax
movq 0x140(%rdi), %rcx
movq 0x10(%rax), %rdx
cmpq %rcx, (%rdx,%rsi,8)
je 0x9ca9
movq 0xe8(%rdi), %rdx
movq 0x108(%rdi), %r8
leaq 0x1(%r8), %r9
movq %r9, 0x108(%rdi)
movq %rsi, 0x8(%rdx,%r8,8)
movq 0x10(%rax), %rax
movq %rcx, (%rax,%rsi,8)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_protected_at
s7_pointer s7_gc_protected_at(s7_scheme *sc, s7_int loc)
    {
        s7_pointer obj;

        obj = sc->unspecified;
        if (loc < sc->protected_objects_size)
            obj = vector_element(sc->protected_objects, loc);
        if (obj == sc->unused)
            return(sc->unspecified);

        return(obj);
    }

// Assembly:
leaq 0x130(%rdi), %rcx
movq %rcx, %rax
cmpq %rsi, 0xf0(%rdi)
jle 0x9cd7
movq 0xd0(%rdi), %rax
shlq $0x3, %rsi
addq 0x10(%rax), %rsi
movq %rsi, %rax
movq (%rax), %rax
cmpq 0x140(%rdi), %rax
je 0x9ce4
retq
movq (%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_symbol_with_length
static inline s7_pointer make_symbol_with_length(s7_scheme *sc, const char *name, s7_int len)
    {
        s7_pointer x;
        uint64_t hash;
        uint32_t location;

        hash = raw_string_hash((const uint8_t *)name, len);
        location = hash % SYMBOL_TABLE_SIZE;

        if (len <= 8)
        {
            for (x = vector_element(sc->symbol_table, location); is_pair(x); x = cdr(x))
                if ((hash == pair_raw_hash(x)) &&
                        (len == pair_raw_len(x)))
                    return(car(x));
        }
        else
        {
            for (x = vector_element(sc->symbol_table, location); is_pair(x); x = cdr(x))
                if ((hash == pair_raw_hash(x)) &&
                        (len == pair_raw_len(x)) &&
                        (strings_are_equal_with_length(name, pair_raw_name(x), len))) /* length here because name might not be null-terminated */
                    return(car(x));
        }
        return(new_symbol(sc, name, len, hash, location));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
cmpq $0x8, %rdx
jg 0x9dd7
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x93e0
jmp 0x9e12
movq (%r14), %r13
movq %r13, 0x8(%rsp)
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
leaq 0x8(%r14), %rsi
cmpq $0x10, %rbx
movl $0x10, %edx
cmovlq %rbx, %rdx
addq $-0x8, %rdx
movq %r12, %rdi
callq 0x93e0
addq (%r12), %r13
movq %r13, 0x8(%rsp)
movq 0x8(%rsp), %r12
movabsq $-0x7fecfd2d94c4151b, %rcx # imm = 0x801302D26B3BEAE5
movq %r12, %rax
mulq %rcx
shrq $0xe, %rdx
imull $0x7fed, %edx, %eax     # imm = 0x7FED
movl %r12d, %r13d
subl %eax, %r13d
movq 0x148(%r15), %rax
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rbp
movb (%rbp), %al
cmpq $0x8, %rbx
jg 0x9e6d
cmpb $0x1, %al
jne 0x9e9c
cmpq 0x18(%rbp), %r12
jne 0x9e61
movl 0x2c(%rbp), %eax
cmpq %rbx, %rax
je 0x9ebe
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
je 0x9e53
jmp 0x9e9c
cmpb $0x1, %al
jne 0x9e9c
cmpq 0x18(%rbp), %r12
jne 0x9e92
movl 0x2c(%rbp), %eax
cmpq %rbx, %rax
jne 0x9e92
movq 0x20(%rbp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x9253a
testb %al, %al
jne 0x9ebe
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
je 0x9e71
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movl %r13d, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa5ef
movq 0x8(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_symbol_table_find_name
s7_pointer s7_symbol_table_find_name(s7_scheme *sc, const char *name)
    {
        uint64_t hash;
        uint32_t location;
        s7_pointer result;

        hash = raw_string_hash((const uint8_t *)name, safe_strlen(name));
        location = hash % SYMBOL_TABLE_SIZE;
        result = symbol_table_find_by_name(sc, name, hash, location);
        if (is_null(result))
            return(NULL);

        return(result);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x9f03
cmpb $0x0, (%rbx)
je 0x9f03
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%rbx,%rax)
movq %rdx, %rax
jne 0x9ef3
jmp 0x9f05
xorl %edx, %edx
movq $0x0, 0x8(%rsp)
cmpq $0x8, %rdx
jg 0x9f23
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x93e0
jmp 0x9f5f
movq (%rbx), %r12
movq %r12, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq $0x0, (%r15)
leaq 0x8(%rbx), %rsi
cmpq $0x10, %rdx
movl $0x10, %eax
cmovlq %rdx, %rax
addq $-0x8, %rax
movq %r15, %rdi
movq %rax, %rdx
callq 0x93e0
addq (%r15), %r12
movq %r12, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movabsq $-0x7fecfd2d94c4151b, %rdx # imm = 0x801302D26B3BEAE5
movq %rcx, %rax
mulq %rdx
shrq $0xe, %rdx
imull $0x7fed, %edx, %eax     # imm = 0x7FED
movl %ecx, %esi
subl %eax, %esi
movq 0x110(%r14), %rdx
movq 0x148(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax,%rsi,8), %rax
movq %rdx, %rsi
cmpq %rdx, %rax
je 0x9fd8
cmpq %rcx, 0x18(%rax)
jne 0x9fc6
movq 0x20(%rax), %rsi
xorl %edi, %edi
movb (%rbx,%rdi), %r8b
movb (%rsi,%rdi), %r9b
testb %r8b, %r8b
je 0x9fc1
incq %rdi
cmpb %r9b, %r8b
je 0x9fac
cmpb %r9b, %r8b
je 0x9fd4
movq 0x10(%rax), %rax
cmpq %rdx, %rax
jne 0x9fa0
movq %rdx, %rsi
jmp 0x9fd8
movq 0x8(%rax), %rsi
xorl %eax, %eax
cmpq %rdx, %rsi
cmovneq %rsi, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x148(%r14), %rax
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %r12
cmpq 0x110(%r14), %r12
je 0xa038
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0xa0aa
movq 0x10(%r12), %r12
jmp 0xa011
incq %r15
cmpq $0x7fed, %r15           # imm = 0x7FED
jne 0xa002
leaq 0x10a3e1(%rip), %rdi    # 0x11442c
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0xa0aa
leaq 0x10ab4f(%rip), %rdi    # 0x114bab
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0xa0aa
leaq 0x10acb6(%rip), %rdi    # 0x114d23
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0xa0aa
leaq 0x108e56(%rip), %rdi    # 0x112ed4
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0xa0aa
leaq 0x108e52(%rip), %rdi    # 0x112ee1
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0xa0aa
leaq 0x108e48(%rip), %rdi    # 0x112ee8
movq %rbx, %rsi
callq *%r13
testb %al, %al
je 0xa0b6
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x108e31(%rip), %rdi    # 0x112eee
movq %rbx, %rsi
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb $0x1, %bpl
xorl %r12d, %r12d
movq 0x148(%r15), %rax
movq 0x10(%rax), %rax
movq (%rax,%r12,8), %r13
cmpq 0x110(%r15), %r13
je 0xa11c
movq 0x8(%r13), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq *%r14
testb %al, %al
jne 0xa137
movq 0x10(%r13), %r13
jmp 0xa0f7
cmpq $0x7fec, %r12           # imm = 0x7FEC
leaq 0x1(%r12), %rax
setb %bpl
movq %rax, %r12
cmpq $0x7fed, %rax           # imm = 0x7FED
jne 0xa0e8
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x20, %r13d
testq %rsi, %rsi
je 0xa184
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0xa18b
movl $0x1f, %r13d
cmpb $0x0, -0x1f(%r12,%r13)
leaq 0x1(%r13), %r13
jne 0xa176
jmp 0xa18b
leaq 0x11b233(%rip), %r12    # 0x1253be
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa305
movq %rax, %r14
movq (%rax), %r15
xorl %eax, %eax
movb %al, (%r15)
movl 0x220(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x220(%rbx)
leaq 0xb6f(%rbx), %r9
movb %al, 0xb6f(%rbx)
leaq 0x11526c(%rip), %rsi    # 0x11f430
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r8
subq %rax, %r8
movb (%rsi,%r8), %al
movb %al, -0x1(%r9)
decq %r9
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0xa1ce
xorl %ebp, %ebp
movq %rbp, (%rsp)
leaq 0x108cee(%rip), %rdx    # 0x112ef5
leaq 0x108ce9(%rip), %r8     # 0x112ef7
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xa4d7
movq %rax, %r12
movq %rbp, 0x8(%rsp)
cmpq $0x8, %rax
jg 0xa23e
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x93e0
jmp 0xa279
movq (%r15), %rbp
movq %rbp, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq $0x0, (%r13)
leaq 0x8(%r15), %rsi
cmpq $0x10, %r12
movl $0x10, %edx
cmovlq %r12, %rdx
addq $-0x8, %rdx
movq %r13, %rdi
callq 0x93e0
addq (%r13), %rbp
movq %rbp, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movabsq $-0x7fecfd2d94c4151b, %rdx # imm = 0x801302D26B3BEAE5
movq %rcx, %rax
mulq %rdx
shrq $0xe, %rdx
imull $0x7fed, %edx, %eax     # imm = 0x7FED
movl %ecx, %r8d
subl %eax, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xa5ef
movq %rax, %r15
movslq 0x8(%r14), %rax
cmpq $0x11, %rax
jne 0xa2de
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa2cd
callq 0x9050
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
addq $0x838, %rbx            # imm = 0x838
jmp 0xa2e9
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x58, %rsp
movq %rdx, -0x50(%rsp)
movq %rcx, -0x48(%rsp)
movq %r8, -0x40(%rsp)
movq %r9, -0x38(%rsp)
testb %al, %al
je 0xa51a
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)
addq %rdi, %rsi
movq %rdi, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, (%rcx)
je 0xa531
cmpq %rsi, %rcx
movq %rax, %rcx
jb 0xa520
leaq -0x60(%rsp), %rcx
movq %rcx, -0x70(%rsp)
leaq 0x60(%rsp), %rcx
movq %rcx, -0x78(%rsp)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, -0x80(%rsp)
movl $0x10, %edx
cmpq $0x28, %rdx
ja 0xa572
movl $0x10, %ecx
addq -0x70(%rsp), %rcx
addl $0x8, %edx
movl %edx, -0x80(%rsp)
jmp 0xa580
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x78(%rsp)
decq %rax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xa5e4
movb (%rcx), %dl
testb %dl, %dl
setne %r8b
cmpq %rsi, %rax
setb %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0xa5b9
incq %rcx
movb %dl, (%rax)
incq %rax
movb (%rcx), %dl
testb %dl, %dl
je 0xa5b9
incq %rcx
cmpq %rsi, %rax
jb 0xa5a6
movl -0x80(%rsp), %edx
cmpq $0x28, %rdx
ja 0xa5d4
movq %rdx, %rcx
addq -0x70(%rsp), %rcx
addl $0x8, %edx
movl %edx, -0x80(%rsp)
jmp 0xa583
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x78(%rsp)
jmp 0xa583
movb $0x0, (%rax)
subq %rdi, %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rax
cmpq $0x11, %rax
jne 0xa9db
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa9cb
callq 0x9050
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
addq $0x838, %r14            # imm = 0x838
jmp 0xa9e6
leaq (%r14,%rax,8), %r14
addq $0x838, %r14            # imm = 0x838
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: symbol_to_slot
static inline s7_pointer symbol_to_slot(s7_scheme *sc, s7_pointer symbol)
    {
        s7_pointer x;
        if (let_id(sc->envir) == symbol_id(symbol))
            return(local_slot(symbol));
        for (x = sc->envir; symbol_id(symbol) < let_id(x); x = outlet(x));
        if (let_id(x) == symbol_id(symbol))
            return(local_slot(symbol));
        for (; is_let(x); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == symbol)
                    return(y);
        }
        return(global_slot(symbol));
    }

// Assembly:
movq 0x8(%rdi), %rdx
movq 0x20(%rsi), %rax
movl $0x18, %ecx
cmpq %rax, 0x18(%rdx)
je 0xcd10
movq 0x18(%rdx), %rdi
cmpq %rdi, %rax
jge 0xccd4
movq 0x10(%rdx), %rdx
jmp 0xccc5
cmpq %rax, %rdi
je 0xcd10
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xcd10
movq 0x8(%rdx), %rax
testq %rax, %rax
sete %r8b
je 0xccfc
cmpq %rsi, 0x8(%rax)
je 0xccff
movq 0x18(%rax), %rax
jmp 0xcce7
movq %rdi, %rax
testb %r8b, %r8b
je 0xcd14
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rax, %rdi
je 0xcce3
movq (%rsi,%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: remove_function_from_heap
static void remove_function_from_heap(s7_scheme *sc, s7_pointer value)
    {
        s7_pointer lt;

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0xa305
movq %rax, %r15
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xae39
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
callq 0x93e0
movslq 0x8(%rbx), %rax
cmpq $0x11, %rax
jne 0xae67
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xae57
callq 0x9050
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
addq $0x838, %r14            # imm = 0x838
jmp 0xae72
leaq (%r14,%rax,8), %r14
addq $0x838, %r14            # imm = 0x838
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, (%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xb195
movq %r12, %rdi
callq 0xb389
movq 0x90(%r12), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r12)
movq -0x8(%rax), %rax
movq $0x20, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x8(%r14)
movq $-0x112201, %rcx        # imm = 0xFFEEDDFF
andq (%rbx), %rcx
orq $0x100000, %rcx         # imm = 0x100000
movq %rcx, (%rbx)
movq 0x18(%r14), %rcx
cmpq 0x20(%rbx), %rcx
jl 0xb1f5
movq %rax, 0x18(%rbx)
movq 0x18(%r14), %rcx
movq %rcx, 0x20(%rbx)
incl 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_varlet
s7_pointer s7_varlet(s7_scheme *sc, s7_pointer env, s7_pointer symbol, s7_pointer value)
    {
        if (!is_let(env))
            return(wrong_type_argument_with_type(sc, sc->varlet_symbol, 1, env, a_let_string));

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

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

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

// Assembly:
pushq %rbx
movq %rsi, %rax
cmpb $0x1c, (%rsi)
jne 0xb29d
movq %rcx, %rbx
movq %rdx, %rcx
cmpb $0xa, (%rdx)
jne 0xb2c2
movq 0x10(%rcx), %rdx
movb (%rdx), %sil
cmpb $0x20, %sil
jne 0xb2e5
movq 0x10(%rdx), %r8
cmpb $0x9, (%r8)
jne 0xb2e5
movq 0x1640(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x1436fe(%rip), %rdx    # 0x14e960
movq 0x140(%rdi), %r8
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r10
movq (%rax,%r10,8), %r9
leal 0x1(%r10), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x107c92(%rip), %rax    # 0x112f21
movq %rax, 0x10(%r9)
movq $0x14, 0x8(%r9)
jmp 0xb2e2
movq 0x1640(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x1436a9(%rip), %rdx    # 0x14e958
movq 0x140(%rdi), %r8
movq 0x14769b(%rip), %r9     # 0x152958
movq %rax, %rcx
jmp 0xb2e2
movq 0x1640(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x14368c(%rip), %rdx    # 0x14e960
movq 0x140(%rdi), %r8
movq 0x14767e(%rip), %r9     # 0x152960
popq %rbx
jmp 0xb31d
cmpq %rax, 0x150(%rdi)
je 0xb2fe
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0xb169
jmp 0xb318
cmpb $0x20, %sil
jne 0xb30a
movq %rbx, 0x10(%rdx)
jmp 0xb318
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0xaaca
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: wrong_type_arg_error_prepackaged
static s7_pointer wrong_type_arg_error_prepackaged(s7_scheme *sc, s7_pointer caller, s7_pointer arg_n, s7_pointer arg, s7_pointer typnam, s7_pointer descr)
                {
                    /* info list is '(format_string caller arg_n arg type_name descr) */
                    s7_pointer p;
                    p = cdr(sc->wrong_type_arg_info);  /* info list is '(format_string caller arg_n arg type_name descr) */
                    set_car(p, caller);  p = cdr(p);
                    set_car(p, arg_n);   p = cdr(p);
                    set_car(p, arg);     p = cdr(p);
                    set_car(p, (typnam == sc->unused) ? prepackaged_type_name(sc, arg) : typnam);
                    p = cdr(p);
                    set_car(p, descr);
                    return(s7_error(sc, sc->wrong_type_arg_symbol, sc->wrong_type_arg_info));
                }

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x20(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rdi)
movq 0x1238(%rdi), %rdx
callq 0x99ef
movq 0x728(%rbx), %rcx
movq %r12, 0x8(%rcx)
movq 0x728(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r15, 0x8(%rcx)
movq 0x728(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, 0x8(%rcx)
movq 0x728(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbd41
movq 0x50(%rbx), %rcx
leaq -0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq -0x20(%rcx), %rdx
movq %rdx, (%rbx)
movq -0x10(%rcx), %rcx
movq %rcx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_set_curlet
s7_pointer s7_set_curlet(s7_scheme *sc, s7_pointer e)
    {
        s7_pointer old_e;
        old_e = sc->envir;
        sc->envir = e;

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

        return(old_e);
    }

// Assembly:
movq 0x8(%rdi), %rax
movq %rsi, 0x8(%rdi)
cmpb $0x1c, (%rsi)
jne 0xcc46
cmpq $0x0, 0x18(%rsi)
jle 0xcc46
movq 0x250(%rdi), %rcx
incq %rcx
movq %rcx, 0x250(%rdi)
movq %rcx, 0x18(%rsi)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0xcc46
movq 0x8(%rcx), %rdx
movq 0x20(%rdx), %rsi
cmpq 0x250(%rdi), %rsi
je 0xcc40
movq %rcx, 0x18(%rdx)
movq 0x250(%rdi), %rsi
movq %rsi, 0x20(%rdx)
incl 0x28(%rdx)
movq 0x18(%rcx), %rcx
jmp 0xcc18
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_symbol_local_value
s7_pointer s7_symbol_local_value(s7_scheme *sc, s7_pointer sym, s7_pointer local_env)
    {
        /* restrict the search to local_env outward */
        if ((local_env == sc->rootlet) || (is_global(sym)))
        {
            if (is_slot(global_slot(sym)))
                return(slot_value(global_slot(sym)));
            return(sc->undefined);
        }

        if (is_let(local_env))
        {
            s7_pointer x;

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

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

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

// Assembly:
cmpq %rdx, 0x150(%rdi)
je 0xcd96
testb $0x1, 0x2(%rsi)
jne 0xcd96
cmpb $0x1c, (%rdx)
jne 0xaa24
movq 0x20(%rsi), %rax
cmpq %rax, 0x18(%rdx)
je 0xcd62
movq 0x18(%rdx), %rcx
cmpq %rcx, %rax
jge 0xcd5d
movq 0x10(%rdx), %rdx
jmp 0xcd4e
cmpq %rax, %rcx
jne 0xcd68
movq 0x18(%rsi), %rax
jmp 0xcd9f
cmpb $0x1c, (%rdx)
jne 0xcd96
movq 0x8(%rdx), %r8
testq %r8, %r8
sete %cl
je 0xcd89
cmpq %rsi, 0x8(%r8)
je 0xcd85
movq 0x18(%r8), %r8
jmp 0xcd71
movq 0x10(%r8), %rax
testb %cl, %cl
je 0xcdab
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
je 0xcd6d
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
jne 0xcda4
movq 0x10(%rax), %rax
retq
movq 0x128(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_symbol_set_value
s7_pointer s7_symbol_set_value(s7_scheme *sc, s7_pointer sym, s7_pointer val)
    {
        s7_pointer x;
        /* if immutable should this return an error? */
        x = symbol_to_slot(sc, sym);
        if (is_slot(x))
            slot_set_value(x, val); /* with_hook? */
        return(val);
    }

// Assembly:
movq %rdx, %rax
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %r8
movq 0x20(%rsi), %rdi
movl $0x18, %ecx
cmpq %rdi, %r8
je 0xce10
jle 0xcdd4
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %r8
cmpq %r8, %rdi
jl 0xcdc7
cmpq %rdi, %r8
je 0xce10
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xce10
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
sete %r9b
je 0xcdfc
cmpq %rsi, 0x8(%rdi)
je 0xcdff
movq 0x18(%rdi), %rdi
jmp 0xcde7
movq %r8, %rdi
testb %r9b, %r9b
je 0xce14
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rdi, %r8
je 0xcde3
movq (%rsi,%rcx), %rdi
cmpb $0x20, (%rdi)
jne 0xce1d
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_is_defined
bool s7_is_defined(s7_scheme *sc, const char *name)
    {
        s7_pointer x;
        x = s7_symbol_table_find_name(sc, name);
        if (x)
        {
            x = symbol_to_slot(sc, x);
            return(is_slot(x));
        }
        return(false);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x9ed1
testq %rax, %rax
je 0xce99
movq 0x8(%rbx), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0xce8d
jle 0xce51
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0xce44
cmpq %rsi, %rdi
je 0xce8d
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xce8d
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
sete %r8b
je 0xce79
cmpq %rax, 0x8(%rsi)
je 0xce7c
movq 0x18(%rsi), %rsi
jmp 0xce64
movq %rdi, %rsi
testb %r8b, %r8b
je 0xce91
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rsi, %rdi
je 0xce60
movq (%rax,%rcx), %rsi
cmpb $0x20, (%rsi)
sete %al
jmp 0xce9b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_define
void s7_define(s7_scheme *sc, s7_pointer envir, s7_pointer symbol, s7_pointer value)
    {
        s7_pointer x;
        if ((envir == sc->nil) ||
                (envir == sc->rootlet))
            envir = sc->shadow_rootlet;
        x = symbol_to_local_slot(sc, symbol, envir);
        if (is_slot(x))
            slot_set_value_with_hook(x, value);
        else
        {
            s7_make_slot(sc, envir, symbol, value); /* I think this means C code can override "constant" defs */
            /* if envir is sc->nil or rootlet, s7_make_slot makes a permanent_slot */
            if ((envir == sc->shadow_rootlet) &&
                    (!is_slot(global_slot(symbol))))
            {
                set_global(symbol); /* is_global => global_slot is usable */
                set_global_slot(symbol, local_slot(symbol));
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
cmpq %rsi, 0x110(%rdi)
je 0xcec4
movq %rsi, %r12
cmpq %rsi, 0x150(%r15)
jne 0xcecb
movq 0x158(%r15), %r12
cmpb $0x1c, (%r12)
jne 0xcef2
cmpq $0x0, 0x20(%rbx)
je 0xcefc
movq 0x8(%r12), %r13
testq %r13, %r13
sete %al
je 0xcefc
cmpq %rbx, 0x8(%r13)
je 0xcef8
movq 0x18(%r13), %r13
jmp 0xcede
leaq 0x10(%rbx), %rax
jmp 0xcf03
testb %al, %al
je 0xcf06
leaq 0x128(%r15), %rax
movq (%rax), %r13
cmpb $0x20, (%r13)
jne 0xcf43
movq 0x200(%r15), %rax
movq 0x18e0(%r15), %rsi
movq 0x18(%rax), %rdx
movq %r15, %rdi
callq 0xcd2c
cmpb $0x1, (%rax)
jne 0xcf82
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xadbc
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xaaca
cmpq 0x158(%r15), %r12
jne 0xcf86
movq 0x10(%rbx), %rax
cmpb $0x20, (%rax)
je 0xcf86
movq (%rbx), %rax
btl $0x14, %eax
jb 0xcf78
orq $0x10000, %rax          # imm = 0x10000
movq %rax, (%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
jmp 0xcf86
movq %r14, 0x10(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_define_variable_with_documentation
s7_pointer s7_define_variable_with_documentation(s7_scheme *sc, const char *name, s7_pointer value, const char *help)
    {
        s7_pointer sym;
        sym = s7_define_variable(sc, name, value);
        symbol_set_has_help(sym);
        symbol_set_help(sym, copy_string(help));
        return(sym);
    }

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd13a
cmpb $0x0, (%r15)
je 0xd13a
movq $-0x1, %rax
leaq 0x1(%rax), %r12
cmpb $0x0, 0x1(%r15,%rax)
movq %r12, %rax
jne 0xd129
jmp 0xd13d
xorl %r12d, %r12d
leaq 0x2(%r12), %rsi
movq %rbx, %rdi
callq 0xa305
movq %rax, %r14
movq (%rax), %r13
leaq 0x1125bc(%rip), %rsi    # 0x11f713
movq %r13, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xd1cb
incq %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x9d9f
movq %rax, %r15
movslq 0x8(%r14), %rax
cmpq $0x11, %rax
jne 0xd1a9
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd198
callq 0x9050
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
addq $0x838, %rbx            # imm = 0x838
jmp 0xd1b4
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: catstrs_direct
static size_t catstrs_direct(char *dst, const char *s1, ...) /* NULL-terminated arg list, dst is destination only (assumed empty), all args known to fit in dst */
    {
        const char *s;
        char *d;
        va_list ap;
        d = dst;
        va_start(ap, s1);
        for (s = s1; s != NULL; s = va_arg(ap, const char *))
            while (*s) {*d++ = *s++;}
        *d = '\0';
        va_end (ap);
        return(d - dst);
    }

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xd20f
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
movq %rdi, %rax
testq %rsi, %rsi
je 0xd280
movq %rdi, %rax
movb (%rsi), %cl
testb %cl, %cl
je 0xd24f
incq %rsi
movb %cl, (%rax)
incq %rax
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0xd241
movl -0x80(%rsp), %edx
cmpq $0x28, %rdx
ja 0xd26a
movq %rdx, %rcx
addq -0x70(%rsp), %rcx
addl $0x8, %edx
movl %edx, -0x80(%rsp)
jmp 0xd278
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x78(%rsp)
movq (%rcx), %rsi
testq %rsi, %rsi
jne 0xd238
movb $0x0, (%rax)
subq %rdi, %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movzbl (%rdi), %ecx
leaq 0x1456b7(%rip), %rax    # 0x152970
cmpb $0x1, (%rcx,%rax)
jne 0xd2ce
cmpb $0xb, %cl
jne 0xd2d6
cmpq $0x0, 0x8(%rdi)
setne %dl
jmp 0xd2d8
cmpb $0x21, %cl
je 0xd2e3
xorl %eax, %eax
retq
xorl %edx, %edx
xorl %eax, %eax
cmpb $0x21, %cl
jne 0xd2d5
testb %dl, %dl
je 0xd2d5
movq 0x8(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_c_pointer_with_type
s7_pointer s7_make_c_pointer_with_type(s7_scheme *sc, void *ptr, s7_pointer type, s7_pointer info)
    {
        s7_pointer x;
        new_cell(sc, x, T_C_POINTER);
        c_pointer(x) = ptr;
        c_pointer_type(x) = type;
        c_pointer_info(x) = info;
        c_pointer_weak1(x) = sc->F;
        c_pointer_weak2(x) = sc->F;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xd321
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x21, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq 0x120(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x120(%rbx), %rcx
movq %rcx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: add_to_gc_list
static inline void add_to_gc_list(gc_list *gp, s7_pointer p)
    {
        if (gp->loc == gp->size)
        {
            gp->size *= 2;
            gp->list = (s7_pointer *)realloc(gp->list, gp->size * sizeof(s7_pointer));
        }
        gp->list[gp->loc++] = p;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
cmpq %rsi, 0x10(%rdi)
jne 0xd975
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq