LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: local_strncmp
static bool local_strncmp(const char *s1, const char *s2, size_t n)
    {
#if S7_ALIGNED
        return(strncmp(s1, s2, n) == 0);
#else
#if (defined(__x86_64__) || defined(__i386__)) /* unaligned accesses are safe on i386 hardware, sez everyone */
        if (n >= 8)
        {
            int64_t *is1, *is2;
            size_t n8 = n >> 3;
            is1 = (int64_t *)s1;
            is2 = (int64_t *)s2;
            do {if (*is1++ != *is2++) return(false);} while (--n8 > 0);
            s1 = (const char *)is1;
            s2 = (const char *)is2;
            n &= 7;
        }
#endif
        while (n > 0)
        {
            if (*s1++ != *s2++) return(false);
            n--;
        }
        return(true);
#endif
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x8, -0x20(%rsp)
jb 0xc0999
movq -0x20(%rsp), %rax
shrq $0x3, %rax
movq %rax, -0x38(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rsp)
movq (%rax), %rax
movq -0x30(%rsp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x30(%rsp)
cmpq (%rcx), %rax
je 0xc0961
movb $0x0, -0x1(%rsp)
jmp 0xc09eb
jmp 0xc0963
movq -0x38(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rsp)
cmpq $0x0, %rax
ja 0xc092d
movq -0x28(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
andq $0x7, %rax
movq %rax, -0x20(%rsp)
jmp 0xc099b
cmpq $0x0, -0x20(%rsp)
jbe 0xc09e6
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movsbl (%rax), %eax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xc09d6
movb $0x0, -0x1(%rsp)
jmp 0xc09eb
movq -0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xc099b
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: alloc_symbol
static uint8_t *alloc_symbol(s7_scheme *sc)
    {
#define SYMBOL_SIZE (3 * sizeof(s7_cell) + sizeof(block_t))
#define ALLOC_SYMBOL_SIZE (64 * SYMBOL_SIZE)
        uint8_t *result;

        if (sc->alloc_symbol_k == ALLOC_SYMBOL_SIZE)
        {
            sc->alloc_symbol_cells = (uint8_t *)malloc(ALLOC_SYMBOL_SIZE);
            sc->alloc_symbol_k = 0;
        }
        result = &(sc->alloc_symbol_cells[sc->alloc_symbol_k]);
        sc->alloc_symbol_k += SYMBOL_SIZE;
        return(result);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x7f8(%rax), %eax
cmpq $0x2e00, %rax           # imm = 0x2E00
jne 0xc0aa4
movl $0x2e00, %edi           # imm = 0x2E00
callq 0x9480
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x828(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x7f8(%rax)
movq 0x10(%rsp), %rax
movq 0x828(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x7f8(%rcx), %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x7f8(%rax), %ecx
addq $0xb8, %rcx
movl %ecx, 0x7f8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: petrify
static inline s7_pointer petrify(s7_scheme *sc, s7_pointer x)
    {
        s7_pointer p;
        int64_t loc;
        loc = heap_location(sc, x);
#if S7_DEBUGGING
        check_heap_location(sc, x, loc, __func__, __LINE__);
        petrified_pointers++;
#endif
        p = (s7_pointer)alloc_big_pointer(sc, loc);
        sc->heap[loc] = p;
        free_cell(sc, p);
        unheap(sc, x);
        /* set_immutable(x); */ /* if there are GC troubles, this might catch them? */
        return(x);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2cb30
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc0e80
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2bcd0
movq 0x18(%rsp), %rax
movzwl 0x6(%rax), %ecx
orl $0x4000, %ecx           # imm = 0x4000
movw %cx, 0x6(%rax)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: add_permanent_object
static void add_permanent_object(s7_scheme *sc, s7_pointer obj)
    {
        gc_obj *g;
        g = (gc_obj *)malloc(sizeof(gc_obj));
        g->p = obj;
        g->nxt = sc->permanent_objects;
        sc->permanent_objects = g;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x10, %edi
callq 0x9480
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xc0(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: alloc_big_pointer
static s7_big_cell *alloc_big_pointer(s7_scheme *sc, int64_t loc)
    {
        s7_big_pointer p;
        if (sc->alloc_big_pointer_k == ALLOC_BIG_POINTER_SIZE)
        {
            sc->permanent_cells += ALLOC_BIG_POINTER_SIZE;
            sc->alloc_big_pointer_cells = (s7_big_cell *)calloc(ALLOC_BIG_POINTER_SIZE, sizeof(s7_big_cell));
            sc->alloc_big_pointer_k = 0;
        }
        p = (&(sc->alloc_big_pointer_cells[sc->alloc_big_pointer_k++]));
        p->big_hloc = loc;
        return(p);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x100, 0x810(%rax)     # imm = 0x100
jne 0xc0ee3
movq 0x10(%rsp), %rax
movl 0x7d8(%rax), %ecx
addl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x7d8(%rax)
movl $0x100, %edi            # imm = 0x100
movl $0x38, %esi
callq 0x9360
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x818(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x810(%rax)
movq 0x10(%rsp), %rax
movq 0x818(%rax), %rax
movq 0x10(%rsp), %rdx
movl 0x810(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x810(%rdx)
movl %ecx, %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_rootlet
static void mark_rootlet(s7_scheme *sc)
    {
        s7_pointer ge;
        s7_pointer *tmp, *top;

        ge = sc->rootlet;
        tmp = rootlet_elements(ge);
        top = (s7_pointer *)(tmp + sc->rootlet_entries);

        set_mark(ge);
        while (tmp < top)
            gc_mark(slot_value(*tmp++));
        /* slot_setter is handled below with an explicit list -- more code than its worth probably */
        /* we're not marking slot_symbol above which makes me worry that a top-level gensym won't be protected
         *   (apply define (gensym) '(32)), then try to get the GC to clobber {gensym}-0,
         *   but I can't get it to break, so they must be protected somehow; apparently they are
         *   removed from the heap!  At least:
         *   (define-macro (defit) (let ((n (gensym))) `(define (,n) (format #t "fun")))) (defit)
         *   removes the function from the heap (protecting the gensym).
         */
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x150(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x160(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0xc38d5
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0xc3980
jmp 0xc38aa
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_owlet
static void mark_owlet(s7_scheme *sc)
    {
#if WITH_HISTORY
        {
            s7_pointer p1, p2, p3;
            int32_t i;
            for (i = 1, p1 = sc->eval_history1, p2 = sc->eval_history2, p3 = sc->history_pairs; ; i++, p2 = cdr(p2), p3 = cdr(p3))
            {
                set_mark(p1); /* pointless? they're permanent */
                set_mark(p2);
                set_mark(p3);
                gc_owlet_mark(car(p1));
                gc_owlet_mark(car(p2));
                gc_owlet_mark(car(p3));
                p1 = cdr(p1);
                if (p1 == sc->eval_history1) break; /* these are circular lists */
            }
        }
#endif

        /* sc->error_type and friends are slots in owlet */
        mark_slot(sc->error_type);
        slot_set_value(sc->error_data, sc->F); /* or maybe mark_tree(slot_value(sc->error_data)) ? */
        mark_slot(sc->error_data);
        mark_slot(sc->error_code);
        mark_slot(sc->error_line);
        mark_slot(sc->error_file);
#if WITH_HISTORY
        mark_slot(sc->error_history);
#endif
        set_mark(sc->owlet);
        mark_let(outlet(sc->owlet));
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x1a0(%rax), %rdi
callq 0xc4b50
movq (%rsp), %rax
movq 0x120(%rax), %rcx
movq (%rsp), %rax
movq 0x1a8(%rax), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq 0x1a8(%rax), %rdi
callq 0xc4b50
movq (%rsp), %rax
movq 0x1b0(%rax), %rdi
callq 0xc4b50
movq (%rsp), %rax
movq 0x1b8(%rax), %rdi
callq 0xc4b50
movq (%rsp), %rax
movq 0x1c0(%rax), %rdi
callq 0xc4b50
movq (%rsp), %rax
movq 0x198(%rax), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x198(%rax), %rax
movq 0x10(%rax), %rdi
callq 0xc39c0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_let
static void mark_let(s7_pointer env)
    {
        s7_pointer x;
        for (x = env; is_let(x) && (!is_marked(x)); x = outlet(x))
        {
            s7_pointer y;
            set_mark(x);
            if (has_dox_slot1(x)) mark_slot(let_dox_slot1(x));
            if ((has_dox_slot2(x)) && (is_slot(let_dox_slot2(x)))) mark_slot(let_dox_slot2(x));
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (!is_marked(y)) /* slot value might be the enclosing let */
                    mark_slot(y);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x1c, %ecx
movb %al, 0xf(%rsp)
jne 0xc3a05
movq 0x18(%rsp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xc3a12
jmp 0xc3adb
movq 0x18(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x10000, %rax          # imm = 0x10000
cmpq $0x0, %rax
je 0xc3a49
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xc4b50
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x800000, %rax         # imm = 0x800000
cmpq $0x0, %rax
je 0xc3a7c
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0xc3a7c
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xc4b50
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xc3ac6
movq 0x10(%rsp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
jne 0xc3ab4
movq 0x10(%rsp), %rdi
callq 0xc4b50
jmp 0xc3ab6
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xc3a8a
jmp 0xc3ac8
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xc39d3
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_stack_1
static void mark_stack_1(s7_pointer p, s7_int top)
    {
        s7_pointer *tp, *tend;
        set_mark(p);

        tp = (s7_pointer *)(stack_elements(p));
        if (!tp) return;
        tend = (s7_pointer *)(tp + top);

        while (tp < tend)
        {
            gc_mark(*tp++);
            gc_mark(*tp++);
            gc_mark(*tp++);
            tp++;
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xc3b1b
jmp 0xc3b98
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0xc3b98
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0xc3b31
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_input_port_stack
static void mark_input_port_stack(s7_scheme *sc)
    {
        s7_pointer *p, *tp;
        tp = (s7_pointer *)(sc->input_port_stack + sc->input_port_stack_loc);
        for (p = sc->input_port_stack; p < tp; p++)
            gc_mark(*p);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x178(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x184(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x178(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0xc3c04
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xc3980
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0xc3bdc
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_pair
static void mark_pair(s7_pointer p)
    {
        do {
            set_mark(p);
            gc_mark(car(p)); /* expanding this to avoid recursion is slower */
            p = cdr(p);
        } while ((is_pair(p)) && (!is_marked(p))); /* ((typeflag(p) & (TYPE_MASK | T_GC_MARK)) == T_PAIR) is much slower */
        gc_mark(p);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xc3980
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, 0xf(%rsp)
jne 0xc3c7c
movq 0x10(%rsp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xc3c19
movq 0x10(%rsp), %rdi
callq 0xc3980
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_op_stack
static void mark_op_stack(s7_scheme *sc)
    {
        s7_pointer *p, *tp;
        tp = sc->op_stack_now;
        p = sc->op_stack;
        while (p < tp)
            gc_mark(*p++);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0xc3d8a
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
callq 0xc3980
jmp 0xc3d64
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_permanent_objects
static void mark_permanent_objects(s7_scheme *sc)
    {
        gc_obj *g;
        for (g = sc->permanent_objects; g; g = (gc_obj *)(g->nxt))
            gc_mark(g->p);
        for (g = sc->permanent_lets; g; g = (gc_obj *)(g->nxt))   /* better would be to mark only if the let is active */
            gc_mark(g->p);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc3dcf
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xc3980
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc3daa
movq 0x10(%rsp), %rax
movq 0xc8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc3e05
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xc3980
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc3de0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_lamlets
static void mark_lamlets(s7_scheme *sc)
    {
        s7_int i;
        gc_list *gp;
        gp = sc->lamlets;
        for (i = 0; i < gp->loc; i++)
        {
            s7_pointer s1;
            s1 = gp->list[i];
            if (!is_free_and_clear(s1))
            {
                s7_pointer lt;
                lt = opt3_lamlet(s1);
                if ((is_let(lt)) && (!is_marked(lt)) && (slots_set(lt)))
                {
                    s7_pointer slot;
                    slot = let_slots(lt);
                    if (is_closure(slot_value(slot)))
                    {
                        for (slot = let_slots(closure_let(slot_value(slot))); tis_slot(slot); slot = next_slot(slot))
                            slot_set_value(slot, sc->F);
                    }
                    clear_slots_set(lt);
                }
                gc_mark(lt);
            }
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x7a8(%rax), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jge 0xc3f4b
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xc3f36
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xc3f2c
movq 0x10(%rsp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
jne 0xc3f2c
movq 0x10(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc3f2c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x28, %eax
jne 0xc3f1c
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc3f1a
movq 0x30(%rsp), %rax
movq 0x120(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc3eed
jmp 0xc3f1c
movq 0x10(%rsp), %rax
movzwl 0x6(%rax), %ecx
andl $-0x2, %ecx
movw %cx, 0x6(%rax)
movq 0x10(%rsp), %rdi
callq 0xc3980
jmp 0xc3f38
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xc3e33
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: mark_slot
static inline void mark_slot(s7_pointer p)
    {
        set_mark(T_Slt(p));
        gc_mark(slot_value(p));
        if (slot_has_setter(p))
            gc_mark(slot_setter(p));
        if (slot_has_pending_value(p))
            gc_mark(slot_pending_value(p));
        set_mark(slot_symbol(p));
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xc3980
movq (%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0xc4b96
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xc3980
movq (%rsp), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0xc4bb6
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xc3980
movq (%rsp), %rax
movq 0x8(%rax), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq (%rax), %rcx
movq %rcx, (%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: remove_gensym_from_symbol_table
static void remove_gensym_from_symbol_table(s7_scheme *sc, s7_pointer sym)
    {
        /* sym is a free cell at this point (we're called after the GC), but the name_cell is still intact */
        s7_pointer x, name;
        uint32_t location;

        name = symbol_name_cell(sym);
        location = string_hash(name) % SYMBOL_TABLE_SIZE;
        x = vector_element(sc->symbol_table, location);

        if (car(x) == sym)
            vector_element(sc->symbol_table, location) = cdr(x);
        else
        {
            s7_pointer y;
            for (y = x, x = cdr(x); is_pair(x); y = x, x = cdr(x))
                if (car(x) == sym)
                {
                    set_cdr(y, cdr(x));
                    return;
                }
#if S7_DEBUGGING
            fprintf(stderr, "could not remove %s?\n", string_value(name));
#endif
        }
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl $0x7fed, %ecx           # imm = 0x7FED
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x24(%rsp)
movq -0x8(%rsp), %rax
movq 0x148(%rax), %rax
movq 0x10(%rax), %rax
movl -0x24(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rsp), %rax
jne 0xc4c81
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rsp), %rax
movq 0x148(%rax), %rax
movq 0x10(%rax), %rax
movl -0x24(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0xc4ce8
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xc4ce6
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rsp), %rax
jne 0xc4cca
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xc4ce8
jmp 0xc4ccc
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xc4c99
jmp 0xc4ce8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: process_multivector
static void process_multivector(s7_scheme *sc, s7_pointer s1)
    {
        vdims_t *info;
        info = vector_dimension_info(s1);  /* a multidimensional empty vector can have dimension info, wrapped vectors always have dimension info */
        if ((info) &&
                (info != sc->wrap_only))
        {
            if (vector_elements_should_be_freed(info)) /* a kludge for foreign code convenience */
            {
                free(vector_elements(s1));
                vector_elements_should_be_freed(info) = false;
            }
            liberate(sc, info);
            vector_set_dimension_info(s1, NULL);
        }
        liberate(sc, vector_block(s1));
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xc4d67
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x470(%rcx), %rax
je 0xc4d67
movq (%rsp), %rax
testb $0x1, 0xc(%rax)
je 0xc4d48
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x9050
movq (%rsp), %rax
movb $0x0, 0xc(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xb230
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: free_hash_table
static void free_hash_table(s7_scheme *sc, s7_pointer table)
                {
                    hash_entry_t **entries;
                    entries = hash_table_elements(table);

                    if (hash_table_entries(table) > 0)
                    {
                        s7_int i, len;
                        len = hash_table_mask(table) + 1;

                        for (i = 0; i < len; i++)
                        {
                            hash_entry_t *p, *n;
                            for (p = entries[i++]; p; p = n)
                            {
                                n = hash_entry_next(p);
                                liberate_block(sc, p);
                            }
                            for (p = entries[i]; p; p = n)
                            {
                                n = hash_entry_next(p);
                                liberate_block(sc, p);
                            }
                        }
                    }
                    liberate(sc, hash_table_block(table));
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x18(%rax)
jle 0xc4e82
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jge 0xc4e80
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc4e29
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc5300
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xc4dfa
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc4e6b
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc5300
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xc4e3c
jmp 0xc4e6d
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xc4dcb
jmp 0xc4e82
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rsi
callq 0xb230
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: process_iterator
static void process_iterator(s7_scheme *sc, s7_pointer s1)
    {
        if (is_weak_hash_iterator(s1))
        {
            s7_pointer h;
            clear_weak_hash_iterator(s1);
            h = iterator_sequence(s1);
            if (unchecked_type(h) == T_HASH_TABLE)
            {
#if S7_DEBUGGING
                if (weak_hash_iters(h) == 0)
                    fprintf(stderr, "in gc weak has iters wrapping under!\n");
#endif
                weak_hash_iters(h)--;
            }
        }
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc509a
movq -0x10(%rsp), %rax
movzwl 0x6(%rax), %ecx
andl $-0x5, %ecx
movw %cx, 0x6(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1b, %eax
jne 0xc5098
movq -0x18(%rsp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0xc509a
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: process_input_port
static void process_input_port(s7_scheme *sc, s7_pointer s1)
    {
        if (!port_is_closed(s1))
        {
            if (is_file_port(s1))
            {
                if (port_file(s1))
                {
                    fclose(port_file(s1));
                    port_file(s1) = NULL;
                }
            }
            else
            {
                if ((is_string_port(s1)) &&
                        (port_needs_unprotect(s1)))
                {
                    s7_gc_unprotect_at(sc, port_gc_loc(s1));
                    port_needs_unprotect(s1) = false;
                }
            }
        }
        if (port_needs_free(s1))
            free_port_data(sc, s1);

        if (port_filename(s1))
        {
            liberate(sc, port_filename_block(s1));
            port_filename(s1) = NULL;
        }
        liberate(sc, port_block(s1));
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0xc514b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0xc5105
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xc5103
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x9180
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x8(%rax)
jmp 0xc5149
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0xc5147
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x1(%rax)
je 0xc5147
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rsi
callq 0x9f60
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
jmp 0xc5149
jmp 0xc514b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, (%rax)
je 0xc5168
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc5340
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xc51a0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
callq 0xb230
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: process_input_string_port
static void process_input_string_port(s7_scheme *sc, s7_pointer s1)
    {
#if S7_DEBUGGING
        /* this set of ports is a subset of the ports that respond true to is_string_port --
         *   the latter include file ports fully read into local memory; see read_file which uses add_input_port, not add_input_string_port
         */
        if (port_filename(s1))
            fprintf(stderr, "string input port has a filename: %s\n", port_filename(s1));
        if (port_needs_free(s1))
            fprintf(stderr, "string input port needs data release\n");
#endif

        if (port_needs_unprotect(s1))
        {
            s7_gc_unprotect_at(sc, port_gc_loc(s1));
            port_needs_unprotect(s1) = false;
        }
        liberate(sc, port_block(s1));
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x1(%rax)
je 0xc5201
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rsi
callq 0x9f60
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
callq 0xb230
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: process_output_port
static void process_output_port(s7_scheme *sc, s7_pointer s1)
    {
        close_output_port(sc, s1); /* needed for free filename, etc */
        liberate(sc, port_block(s1));
        if (port_needs_free(s1))
        {
            if (port_data_block(s1))
            {
                liberate(sc, port_data_block(s1));
                port_data_block(s1) = NULL;
            }
            port_needs_free(s1) = false;
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14fd0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, (%rax)
je 0xc52a2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0xc5296
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: free_port_data
static void free_port_data(s7_scheme *sc, s7_pointer s1)
    {
        if (port_data(s1))
        {
            liberate(sc, port_data_block(s1));
            port_data_block(s1) = NULL;
            port_data(s1) = NULL;
            port_data_size(s1) = 0;
        }
        port_needs_free(s1) = false;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc539c
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rsi
callq 0xb230
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: new_frame_in_env
static inline s7_pointer new_frame_in_env(s7_scheme *sc, s7_pointer old_env)
    {
        s7_pointer x;
        new_cell(sc, x, T_LET | T_SAFE_PROCEDURE);
        let_id(x) = ++sc->let_number;
        let_set_slots(x, slot_end(sc));
        set_outlet(x, old_env);
        return(x);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xc53e2
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%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 $0x20001c, (%rax)       # imm = 0x20001C
movq 0x10(%rsp), %rax
movq 0x250(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x250(%rax)
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: check_c_obj_env
static s7_pointer check_c_obj_env(s7_scheme *sc, s7_pointer old_e, s7_pointer caller)
    {
        if (is_c_object(old_e))
            old_e = c_object_let(old_e);
        if (!is_let(old_e))
            return(simple_wrong_type_argument_with_type(sc, caller, old_e, a_let_string));
        return(old_e);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x14, %eax
jne 0xc575e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
je 0xc579d
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x154cf7(%rip), %r8     # 0x21a488
callq 0x14a60
movq %rax, 0x20(%rsp)
jmp 0xc57a7
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_constant_symbol
static inline bool is_constant_symbol(s7_scheme *sc, s7_pointer sym)
    {
        if (is_immutable_symbol(sym))    /* for keywords */
            return(true);
        if (is_possibly_constant(sym))
        {
            s7_pointer slot;
            slot = symbol_to_slot(sc, sym);
            return((is_slot(slot)) && (is_immutable_slot(slot)));
        }
        return(false);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
je 0xc57e9
movb $0x1, 0x27(%rsp)
jmp 0xc584b
movq 0x10(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc5846
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xfc80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, 0x7(%rsp)
jne 0xc583a
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xc584b
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: set_qlist_3
static s7_pointer set_qlist_3(s7_scheme *sc, s7_pointer x1, s7_pointer x2, s7_pointer x3)
    {
        set_car(sc->qlist_3, x1);
        set_cadr(sc->qlist_3, x2);
        set_caddr(sc->qlist_3, x3);
        return(sc->qlist_3);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq 0x728(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq 0x728(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq 0x728(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x728(%rax), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: checked_slot_set_value
static inline s7_pointer checked_slot_set_value(s7_scheme *sc, s7_pointer y, s7_pointer value)
    {
        if (slot_has_setter(y))
            slot_set_value(y, call_setter(sc, y, value));
        else
        {
            if (is_immutable_slot(y))
                return(immutable_object_error(sc, set_elist_3(sc, immutable_error_string, sc->let_set_symbol, slot_symbol(y))));
            slot_set_value(y, value);
        }
        return(slot_value(y));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0xc5e49
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xc5920
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xc5ead
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
je 0xc5e9f
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x154626(%rip), %rsi    # 0x21a498
movq 0x18(%rsp), %rax
movq 0x1240(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
callq 0xf240
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xb800
movq %rax, 0x20(%rsp)
jmp 0xc5ebb
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: copy_counter
static s7_pointer copy_counter(s7_scheme *sc, s7_pointer obj)
    {
        s7_pointer nobj;
        new_cell(sc, nobj, T_COUNTER);
        counter_set_result(nobj, counter_result(obj));
        counter_set_list(nobj, counter_list(obj));
        counter_set_capture(nobj, counter_capture(obj));
        counter_set_let(nobj, counter_let(obj));
        counter_set_slots(nobj, counter_slots(obj));
        return(nobj);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xc65c2
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%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 $0x1f, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: fill_block_list
static void fill_block_list(s7_scheme *sc)
    {
        int32_t i;
        block_t *b;
#define BLOCK_MALLOC_SIZE 256
        b = (block_t *)malloc(BLOCK_MALLOC_SIZE * sizeof(block_t)); /* batch alloc means blocks in this batch can't be freed, only returned to the list */
        sc->block_lists[BLOCK_LIST] = b;
        for (i = 0; i < BLOCK_MALLOC_SIZE - 1; i++)
        {
            block_next(b) = (block_t *)(b + 1);
            block_set_index(b, BLOCK_LIST);
            b++;
        }
        block_next(b) = NULL;
        block_set_index(b, BLOCK_LIST);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x838(%rax)
movl $0x0, 0xc(%rsp)
cmpl $0xff, 0xc(%rsp)
jge 0xc66bd
movq (%rsp), %rcx
addq $0x28, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rax
addq $0x28, %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xc667f
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: string_to_block
static block_t *string_to_block(s7_scheme *sc, const char *p, s7_int len)
    {
        block_t *b;
        char *bp;
        b = mallocate(sc, len + 1);
        bp = (char *)block_data(b);
        memcpy((void *)bp, (void *)p, len);
        bp[len] = '\0';
        return(b);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0xaa80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x93e0
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: integer_to_string_no_length
static char *integer_to_string_no_length(s7_scheme *sc, s7_int num) /* do not free the returned string */
    {
        char *p;
        bool sign;

        if (num == s7_int_min)
            return((char *)"-9223372036854775808");
        p = (char *)(sc->int_to_str2 + INT_TO_STR_SIZE - 1);
        *p-- = '\0';
        sign = (num < 0);
        if (sign) num = -num;
        do {*p-- = "0123456789"[num % 10]; num /= 10;} while (num);
        if (sign)
        {
            *p = '-';
            return(p);
        }
        return(++p);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq 0x153472(%rip), %rax    # 0x21a558
jne 0xc70f9
leaq 0x12705e(%rip), %rax    # 0x1ee14d
movq %rax, -0x8(%rsp)
jmp 0xc71bf
movq -0x10(%rsp), %rax
addq $0xb10, %rax            # imm = 0xB10
addq $0x20, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rsp)
movb $0x0, (%rax)
cmpq $0x0, -0x18(%rsp)
setl %al
andb $0x1, %al
movb %al, -0x21(%rsp)
testb $0x1, -0x21(%rsp)
je 0xc7147
xorl %eax, %eax
subq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0xc7149
movq -0x18(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
leaq 0x126eb6(%rip), %rax    # 0x1ee015
movb (%rax,%rdx), %cl
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %cl, (%rax)
movq -0x18(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0xc7149
testb $0x1, -0x21(%rsp)
je 0xc71ac
movq -0x20(%rsp), %rax
movb $0x2d, (%rax)
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xc71bf
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
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: integer_to_string
static char *integer_to_string(s7_scheme *sc, s7_int num, s7_int *nlen) /* do not free the returned string */
    {
        char *p, *op;
        bool sign;

        if (num == s7_int_min)
        {
            (*nlen) = 20;
            return((char *)"-9223372036854775808");
        }
        p = (char *)(sc->int_to_str1 + INT_TO_STR_SIZE - 1);
        op = p;
        *p-- = '\0';

        sign = (num < 0);
        if (sign) num = -num;  /* we need a positive index below */
        do {*p-- = "0123456789"[num % 10]; num /= 10;} while (num);
        if (sign)
        {
            *p = '-';
            (*nlen) = op - p;
            return(p);
        }

        (*nlen) = op - p - 1;
        return(++p);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
cmpq 0x1532fd(%rip), %rax    # 0x21a558
jne 0xc727a
movq -0x20(%rsp), %rax
movq $0x14, (%rax)
leaq 0x126edd(%rip), %rax    # 0x1ee14d
movq %rax, -0x8(%rsp)
jmp 0xc7378
movq -0x10(%rsp), %rax
addq $0xaf0, %rax            # imm = 0xAF0
addq $0x20, %rax
addq $-0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rsp)
movb $0x0, (%rax)
cmpq $0x0, -0x18(%rsp)
setl %al
andb $0x1, %al
movb %al, -0x31(%rsp)
testb $0x1, -0x31(%rsp)
je 0xc72d2
xorl %eax, %eax
subq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0xc72d4
movq -0x18(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
leaq 0x126d2b(%rip), %rax    # 0x1ee015
movb (%rax,%rdx), %cl
movq -0x28(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x28(%rsp)
movb %cl, (%rax)
movq -0x18(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0xc72d4
testb $0x1, -0x31(%rsp)
je 0xc734c
movq -0x28(%rsp), %rax
movb $0x2d, (%rax)
movq -0x30(%rsp), %rcx
movq -0x28(%rsp), %rax
subq %rax, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xc7378
movq -0x30(%rsp), %rcx
movq -0x28(%rsp), %rax
subq %rax, %rcx
subq $0x1, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: insert_spaces
static void insert_spaces(s7_scheme *sc, char *src, s7_int width, s7_int len)
    {
        s7_int spaces;
        if (width >= sc->num_to_str_size)
        {
            sc->num_to_str_size = width + 1;
            sc->num_to_str = (char *)realloc(sc->num_to_str, sc->num_to_str_size);
        }
        spaces = width - len;
        sc->num_to_str[width] = '\0';
        memmove((void *)(sc->num_to_str + spaces), (void *)src, len);
        memset((void *)(sc->num_to_str), (int)' ', spaces);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movslq 0x7e0(%rcx), %rcx
cmpq %rcx, %rax
jl 0xc73f0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x7e0(%rax)
movq 0x20(%rsp), %rax
movq 0x830(%rax), %rdi
movq 0x20(%rsp), %rax
movslq 0x7e0(%rax), %rsi
callq 0x9510
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x830(%rax)
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x830(%rax), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq 0x830(%rax), %rdi
addq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x9550
movq 0x20(%rsp), %rax
movq 0x830(%rax), %rdi
movq (%rsp), %rdx
movl $0x20, %esi
callq 0x9270
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)