LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x1c, (%rdi)
jne 0x8eb39
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq 0xb7dc0(%rip), %r15     # 0x146770
movq (%rbx), %rcx
testq %rcx, %rcx
js 0x8eb2e
movq %rcx, %rax
orq %r14, %rax
movq %rax, (%rbx)
btl $0x10, %ecx
jae 0x8ea35
movq 0x20(%rbx), %r12
movq (%r12), %rax
orq %r14, %rax
movq %rax, (%r12)
movq 0x10(%r12), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0x8e9f2
movzbl %cl, %eax
callq *(%r15,%rax,8)
movq (%r12), %rax
btl $0x12, %eax
jae 0x8ea10
movq 0x28(%r12), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0x8ea10
movzbl %cl, %eax
callq *(%r15,%rax,8)
movq (%r12), %rax
btl $0x1d, %eax
jae 0x8ea2a
movq 0x20(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x8ea2a
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x8(%r12), %rax
orq %r14, (%rax)
movq (%rbx), %rax
btl $0x17, %eax
jae 0x8eaa9
movq 0x28(%rbx), %r12
cmpb $0x20, (%r12)
jne 0x8eaa9
movq (%r12), %rax
orq %r14, %rax
movq %rax, (%r12)
movq 0x10(%r12), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0x8ea69
movzbl %cl, %eax
callq *(%r15,%rax,8)
movq (%r12), %rax
btl $0x12, %eax
jae 0x8ea87
movq 0x28(%r12), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0x8ea87
movzbl %cl, %eax
callq *(%r15,%rax,8)
movq (%r12), %rax
btl $0x1d, %eax
jae 0x8eaa1
movq 0x20(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x8eaa1
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x8(%r12), %rax
orq %r14, (%rax)
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x8eb21
movq (%r12), %rax
testq %rax, %rax
js 0x8eb1a
orq %r14, %rax
movq %rax, (%r12)
movq 0x10(%r12), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0x8eada
movzbl %cl, %eax
callq *(%r15,%rax,8)
movq (%r12), %rax
btl $0x12, %eax
jae 0x8eaf8
movq 0x28(%r12), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0x8eaf8
movzbl %cl, %eax
callq *(%r15,%rax,8)
movq (%r12), %rax
btl $0x1d, %eax
jae 0x8eb12
movq 0x20(%r12), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x8eb12
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x8(%r12), %rax
orq %r14, (%rax)
movq 0x18(%r12), %r12
jmp 0x8eaad
movq 0x10(%rbx), %rbx
cmpb $0x1c, (%rbx)
je 0x8e9b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
pushq %r15
pushq %r14
pushq %rbx
orb $-0x80, 0x7(%rdi)
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x8eb9d
testq %rsi, %rsi
jle 0x8eb9d
leaq (%rbx,%rsi,8), %r14
leaq 0xb7c14(%rip), %r15     # 0x146770
movq (%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x8eb6e
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x8eb81
movzbl %al, %eax
callq *(%r15,%rax,8)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x8eb94
movzbl %al, %eax
callq *(%r15,%rax,8)
addq $0x20, %rbx
cmpq %r14, %rbx
jb 0x8eb5c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xb7bbc(%rip), %r14     # 0x146770
btsq $0x3f, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x8ebcf
movzbl %al, %eax
callq *(%r14,%rax,8)
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
movq (%rbx), %rax
jne 0x8ebe2
testq %rax, %rax
jns 0x8ebb4
jmp 0x8ebfa
testq %rax, %rax
js 0x8ebfa
movzbl %al, %eax
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
movq (%rdi), %rax
orq %r14, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0x8ec6c
movzbl %cl, %eax
leaq 0xb7b0a(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq (%rbx), %rax
btl $0x12, %eax
jae 0x8ec8e
movq 0x28(%rbx), %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
js 0x8ec8e
movzbl %cl, %eax
leaq 0xb7ae8(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq (%rbx), %rax
btl $0x1d, %eax
jae 0x8ecad
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
js 0x8ecad
movzbl %al, %eax
leaq 0xb7ac6(%rip), %rcx     # 0x146770
callq *(%rcx,%rax,8)
movq 0x8(%rbx), %rax
orq %r14, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x0, 0x10(%rsi)
je 0x8ed6e
movq %rdi, %r14
leaq 0x10(%rbx), %r15
movq 0x8(%rbx), %rax
movq 0x38(%rax), %r12
movslq 0x8(%r12), %rax
cmpq $0x11, %rax
jne 0x8ed45
movq (%r12), %rdi
testq %rdi, %rdi
je 0x8ed33
callq 0x8050
movq $0x0, (%r12)
movl $0x0, 0x8(%r12)
addq $0x838, %r14            # imm = 0x838
jmp 0x8ed50
leaq (%r14,%rax,8), %r14
addq $0x838, %r14            # imm = 0x838
movq (%r14), %rax
movq %rax, 0x18(%r12)
movq %r12, (%r14)
movq 0x8(%rbx), %rax
movq $0x0, 0x38(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x8(%rbx), %rax
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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:
movq %rsi, %rax
movb (%rsi), %cl
cmpb $0x14, %cl
jne 0x8efef
movq 0x18(%rax), %rax
movb (%rax), %cl
cmpb $0x1c, %cl
jne 0x8eff5
retq
movq 0x8(%rdx), %rsi
movq 0x140(%rdi), %rcx
movq 0xbb951(%rip), %r8      # 0x14a958
movq %rax, %rdx
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rsi), %rcx
movb $0x1, %al
btl $0x18, %ecx
jb 0x8f059
btq $0x30, %rcx
jae 0x8f05a
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
movq 0x20(%rsi), %rdx
movl $0x18, %eax
cmpq %rdx, %rdi
je 0x8f04b
jle 0x8f046
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdi
cmpq %rdi, %rdx
jl 0x8f039
cmpq %rdx, %rdi
jne 0x8f05d
movq (%rsi,%rax), %rdx
cmpb $0x20, (%rdx)
jne 0x8f05a
movb 0x3(%rdx), %al
andb $0x1, %al
retq
xorl %eax, %eax
retq
movl $0x10, %eax
cmpb $0x1c, (%rcx)
jne 0x8f04b
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x8f07c
cmpq %rsi, 0x8(%rdx)
je 0x8f04f
movq 0x18(%rdx), %rdx
jmp 0x8f06b
movq 0x10(%rcx), %rcx
jmp 0x8f062
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: integer_to_string_any_base
static size_t integer_to_string_any_base(char *p, s7_int n, int32_t radix)  /* called by number_to_string_with_radix */
    {
        s7_int i, len, end;
        bool sign;
        s7_int pown;

        if ((radix < 2) || (radix > 16))
            return(0);

        if (n == s7_int_min) /* can't negate this, so do it by hand */
        {
            static const char *mnfs[17] = {"","",
                "-1000000000000000000000000000000000000000000000000000000000000000", "-2021110011022210012102010021220101220222",
                "-20000000000000000000000000000000", "-1104332401304422434310311213", "-1540241003031030222122212",
                "-22341010611245052052301", "-1000000000000000000000", "-67404283172107811828",	"-9223372036854775808",
                "-1728002635214590698",	"-41a792678515120368", "-10b269549075433c38", "-4340724c6c71dc7a8", "-160e2ad3246366808", "-8000000000000000"};

            len = safe_strlen(mnfs[radix]);
            memcpy((void *)p, (void *)mnfs[radix], len);
            p[len] = '\0';
            return(len);
        }

        sign = (n < 0);
        if (sign) n = -n;

        /* the previous version that counted up to n, rather than dividing down below n, as here,
         *   could be confused by large ints on 64 bit machines
         */
        pown = n;
        for (i = 1; i < 100; i++)
        {
            if (pown < radix)
                break;
            pown /= (s7_int)radix;
        }
        len = i - 1;
        if (sign) len++;
        end = 0;
        if (sign)
        {
            p[0] = '-';
            end++;
        }
        for (i = len; i >= end; i--)
        {
            p[i] = dignum[n % radix];
            n /= radix;
        }
        p[len + 1] = '\0';
        return(len + 1);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leal -0x11(%rdx), %eax
cmpl $-0xf, %eax
jae 0x90375
xorl %r14d, %r14d
jmp 0x90444
movq %rdi, %rbx
movl 0xba6aa(%rip), %eax     # 0x14aa28
shlq $0x3f, %rax
cmpq %rsi, %rax
jne 0x903ab
movl %edx, %eax
leaq 0xb5970(%rip), %rcx     # 0x145d00
movq (%rcx,%rax,8), %rsi
cmpb $0x0, (%rsi)
je 0x903f2
xorl %eax, %eax
leaq 0x1(%rax), %r14
cmpb $0x0, 0x1(%rsi,%rax)
movq %r14, %rax
jne 0x9039b
jmp 0x903f5
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
movl %edx, %edi
movl $0x1, %edx
cmpq %rdi, %rcx
jb 0x903db
movq %rcx, %rax
movq %rdx, %r8
xorl %edx, %edx
divq %rdi
leaq 0x1(%r8), %rdx
cmpq $0x62, %r8
ja 0x903db
cmpq %rdi, %rax
jge 0x903c4
xorl %eax, %eax
testq %rsi, %rsi
setns %al
movq %rdx, %r14
subq %rax, %r14
testq %rsi, %rsi
js 0x90402
xorl %esi, %esi
jmp 0x9040f
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x83e0
jmp 0x9043f
movb $0x2d, (%rbx)
movl $0x1, %esi
testq %r14, %r14
je 0x9043c
negq %rax
leaq (%rdx,%rax), %r8
incq %r8
leaq 0x8be20(%rip), %r9      # 0x11c240
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movb (%rdx,%r9), %cl
movb %cl, -0x1(%rbx,%r8)
decq %r8
movq %rax, %rcx
cmpq %rsi, %r8
jg 0x90420
incq %r14
movb $0x0, (%rbx,%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdx, %rcx
movl 0xba5d0(%rip), %eax     # 0x14aa28
shlq $0x3f, %rax
cmpq %rsi, %rax
jne 0x90473
leaq 0x86210(%rip), %r8      # 0x116678
movl $0x14, %r10d
jmp 0x90503
pushq %r15
pushq %r14
pushq %rbx
leaq 0xb0f(%rdi), %r8
movb $0x0, 0xb0f(%rdi)
addq $0xb0e, %rdi            # imm = 0xB0E
movq %rsi, %r9
negq %r9
cmovsq %rsi, %r9
movq $-0x1, %r11
xorl %r10d, %r10d
leaq 0x86098(%rip), %rbx     # 0x116540
movabsq $-0x3333333333333333, %r14 # imm = 0xCCCCCCCCCCCCCCCD
movq %r9, %rax
mulq %r14
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %r9, %r15
subq %rax, %r15
movb (%rbx,%r15), %al
movb %al, 0x1(%rdi,%r11)
incq %r10
decq %r11
cmpq $0x9, %r9
movq %rdx, %r9
ja 0x904b2
testq %rsi, %rsi
popq %rbx
popq %r14
popq %r15
js 0x904f1
subq %r10, %r8
jmp 0x90503
movb $0x2d, 0x1(%rdi,%r11)
subq %r10, %rdi
negq %r11
movq %r11, %r10
movq %rdi, %r8
movq %r10, (%rcx)
movq %r8, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movslq 0x7e0(%rdi), %rax
cmpq %rdx, %rax
jle 0x90533
movq 0x830(%r14), %rax
jmp 0x90553
leal 0x1(%rbx), %eax
movl %eax, 0x7e0(%r14)
movq 0x830(%r14), %rdi
movslq %eax, %rsi
callq 0x8510
movq %rax, 0x830(%r14)
movb $0x0, (%rax,%rbx)
subq %r15, %rbx
movq 0x830(%r14), %rdi
addq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x8550
movq 0x830(%r14), %rdi
movl $0x20, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8270
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: find_and_apply_method
static s7_pointer find_and_apply_method(s7_scheme *sc, s7_pointer lt, s7_pointer sym, s7_pointer args)
    {
        s7_pointer func;
        func = find_method(sc, lt, sym);
        if (func != sc->undefined)
            return(s7_apply_function(sc, func, args));
        return(missing_method_error(sc, sym, lt));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x905c9
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaee6
movq 0x1950(%rbx), %rsi
movq 0xc1ce9(%rip), %rax     # 0x1522c0
movq 0x6e8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %r15, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e8(%rbx), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_read_semicolon
static token_t string_read_semicolon(s7_scheme *sc, s7_pointer pt)
    {
        const char *orig_str, *str;
        str = (const char *)(port_data(pt) + port_position(pt));
        orig_str = strchr(str, (int)'\n');
        if (!orig_str)
        {
            port_position(pt) = port_data_size(pt);
            return(TOKEN_EOF);
        }
        port_position(pt) += (orig_str - str + 1); /* + 1 because strchr leaves orig_str pointing at the newline */
        port_line_number(pt)++;
        return(token(sc));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %r12
movq 0x10(%rsi), %r15
addq %r12, %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x81d0
testq %rax, %rax
je 0x90ac0
subq %r15, %r12
addq %r12, %rax
incq %rax
movq %rax, 0x20(%rbx)
movq 0x8(%rbx), %rax
incl 0x20(%rax)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9126a
movq 0x18(%rbx), %rax
movq %rax, 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: terminated_string_read_white_space
static int32_t terminated_string_read_white_space(s7_scheme *sc, s7_pointer pt)
    {
        const uint8_t *str;
        uint8_t c;
        /* here we know we have null termination and white_space[#\null] is false. */

        str = (const uint8_t *)(port_data(pt) + port_position(pt));

        while (white_space[c = *str++]) /* (let ((�a 1)) �a) -- 255 is not -1 = EOF */
            if (c == '\n')
                port_line_number(pt)++;
        if (c)
            port_position(pt) = str - port_data(pt);
        else port_position(pt) = port_data_size(pt);
        return((int32_t)c);
    }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x20(%rsi), %rcx
movq 0xc17eb(%rip), %rdx     # 0x1522d0
addq %rcx, %rax
incq %rax
movzbl -0x1(%rax), %ecx
cmpb $0x1, (%rdx,%rcx)
jne 0x90b0d
cmpb $0xa, %cl
jne 0x90b01
movq 0x8(%rsi), %rcx
incl 0x20(%rcx)
movzbl (%rax), %ecx
incq %rax
cmpb $0x0, (%rdx,%rcx)
jne 0x90af5
testb %cl, %cl
je 0x90b17
subq 0x10(%rsi), %rax
jmp 0x90b1b
movq 0x18(%rsi), %rax
movq %rax, 0x20(%rsi)
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_read_sharp
static s7_pointer string_read_sharp(s7_scheme *sc, s7_pointer pt)
    {
        /* sc->strbuf[0] has the first char of the string we're reading.
         *   since a *#readers* function might want to get further input, we can't mess with the input even when it is otherwise safe
         */
        char *str;
        str = (char *)(port_data(pt) + port_position(pt));

        if (char_ok_in_a_name[(uint8_t)*str])
        {
            s7_int k;
            char * orig_str;
            orig_str = (char *)(str - 1);
            str++;
            while (char_ok_in_a_name[(uint8_t)(*str)]) {str++;}
            k = str - orig_str;
            if (*str != 0)
                port_position(pt) += (k - 1);
            else port_position(pt) += k;

            if ((k + 1) >= sc->strbuf_size)
                resize_strbuf(sc, k + 1);

            memcpy((void *)(sc->strbuf), (void *)orig_str, k);
            sc->strbuf[k] = '\0';
            return(make_sharp_constant(sc, sc->strbuf, WITH_OVERFLOW_ERROR));
        }
        if (sc->strbuf[0] == 'f')
            return(sc->F);
        if (sc->strbuf[0] == 't')
            return(sc->T);
        if (sc->strbuf[0] == '\\')
        {
            /* must be from #\( and friends -- a character that happens to be not ok-in-a-name */
            sc->strbuf[1] = str[0];
            sc->strbuf[2] = '\0';
            port_position(pt)++;
        }
        else sc->strbuf[1] = '\0';
        return(make_sharp_constant(sc, sc->strbuf, WITH_OVERFLOW_ERROR));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x20(%rsi), %rax
movzbl (%r14,%rax), %edx
leaq 0xc4b49(%rip), %rcx     # 0x155a60
cmpb $0x1, (%rdx,%rcx)
jne 0x90f8c
addq %rax, %r14
movl $0x1, %r15d
movzbl (%r14,%r15), %edx
incq %r15
cmpb $0x0, (%rdx,%rcx)
jne 0x90f26
decq %r14
cmpb $0x1, %dl
adcq $-0x1, %rax
addq %r15, %rax
movq %rax, 0x20(%rsi)
leaq 0x1(%r15), %rsi
cmpq 0x4a8(%rbx), %rsi
jl 0x90f5a
movq %rbx, %rdi
callq 0x93c9f
movq 0x4b0(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x83e0
movq 0x4b0(%rbx), %rax
movb $0x0, (%rax,%r15)
movq 0x4b0(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9256e
movq 0x4b0(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x90fbb
cmpl $0x74, %ecx
je 0x90fae
cmpl $0x66, %ecx
jne 0x90fcf
movq 0x120(%rbx), %rax
jmp 0x90fb5
movq 0x118(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movb %dl, 0x1(%rax)
movq 0x4b0(%rbx), %rax
movb $0x0, 0x2(%rax)
incq 0x20(%rsi)
jmp 0x90f78
movb $0x0, 0x1(%rax)
jmp 0x90f78
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_read_line
static s7_pointer string_read_line(s7_scheme *sc, s7_pointer port, bool with_eol, bool copied)
    {
        s7_int i, port_start;
        uint8_t *port_str, *cur, *start;

        port_start = port_position(port);
        port_str = port_data(port);
        start = (uint8_t *)(port_str + port_start);

        cur = (uint8_t *)strchr((const char *)start, (int)'\n'); /* this can run off the end making valgrind unhappy, but I think it's innocuous */
        if (cur)
        {
            port_line_number(port)++;
            i = cur - port_str;
            port_position(port) = i + 1;
            if (copied)
                return(make_string_with_length(sc, (const char *)start, ((with_eol) ? i + 1 : i) - port_start));
            return(wrap_string(sc, (char *)start, ((with_eol) ? i + 1 : i) - port_start));
        }
        i = port_data_size(port);
        port_position(port) = i;
        if (i <= port_start)         /* the < part can happen -- if not caught we try to create a string of length - 1 -> segfault */
            return(eof_object);

        if (copied)
            return(make_string_with_length(sc, (const char *)start, i - port_start));
        return(wrap_string(sc, (char *)start, i - port_start));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq 0x10(%rsi), %rbx
movq 0x20(%rsi), %r15
leaq (%rbx,%r15), %rdi
movq %rdi, 0x8(%rsp)
movl $0xa, %esi
callq 0x81d0
testq %rax, %rax
je 0x91032
movq %rax, %r12
movq 0x8(%r14), %rax
incl 0x20(%rax)
subq %rbx, %r12
leaq 0x1(%r12), %rax
movq %rax, 0x20(%r14)
testb %r13b, %r13b
cmovneq %rax, %r12
subq %r15, %r12
jmp 0x91043
movq 0x18(%r14), %r12
movq %r12, 0x20(%r14)
subq %r15, %r12
jle 0x91134
testb %bpl, %bpl
je 0x91102
movq 0x10(%rsp), %rbx
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x91070
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200013, (%r14)       # imm = 0x200013
leaq 0x1(%r12), %rsi
movq %rbx, %rdi
callq 0x9357
movq %rax, 0x20(%r14)
movq (%rax), %rdi
movq %rdi, 0x10(%r14)
testq %r12, %r12
jle 0x910b4
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x83e0
movq 0x10(%r14), %rdi
movb $0x0, (%rdi,%r12)
movq %r12, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq 0x738(%rbx), %rbx
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
cmpq 0x8(%rbx), %rsi
jne 0x910f4
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%rbx)
movq 0x10(%rbx), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, (%rax,%rsi,8)
jmp 0x9113b
movq 0x10(%rsp), %rdx
movq 0x820(%rdx), %rax
movslq 0x7dc(%rdx), %rcx
movq (%rax,%rcx,8), %r14
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdx)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r14)
movq %r12, 0x8(%r14)
jmp 0x9113b
movq 0xb5625(%rip), %r14     # 0x146760
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: close_input_string
static void close_input_string(s7_scheme *sc, s7_pointer p)
    {
        if (port_filename(p))
        {
            /* for string ports, this is the original input file name */
            liberate(sc, port_filename_block(p));
            port_filename(p) = NULL;
        }
        if (port_needs_unprotect(p))
        {
            s7_gc_unprotect_at(sc, port_gc_loc(p));
            port_needs_unprotect(p) = false;
        }
        if (port_needs_free(p))
            free_port_data(sc, p);

        port_port(p)->pf = &closed_port_functions;
        port_set_closed(p, true);
        port_position(p) = 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x911d8
movq 0x18(%rax), %r15
movslq 0x8(%r15), %rax
cmpq $0x11, %rax
jne 0x911b4
movq (%r15), %rdi
testq %rdi, %rdi
je 0x911a3
callq 0x8050
movq $0x0, (%r15)
movl $0x0, 0x8(%r15)
leaq 0x838(%r14), %rax
jmp 0x911be
leaq (%r14,%rax,8), %rax
addq $0x838, %rax            # imm = 0x838
movq (%rax), %rcx
movq %rcx, 0x18(%r15)
movq %r15, (%rax)
movq 0x8(%rbx), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
cmpb $0x1, 0x1(%rax)
jne 0x91235
movq 0x28(%rax), %rcx
cmpq %rcx, 0xf0(%r14)
jle 0x9122d
movq 0xd0(%r14), %rdx
movq 0x140(%r14), %rax
movq 0x10(%rdx), %rsi
cmpq %rax, (%rsi,%rcx,8)
je 0x91225
movq 0xe8(%r14), %rsi
movq 0x108(%r14), %rdi
leaq 0x1(%rdi), %r8
movq %r8, 0x108(%r14)
movq %rcx, 0x8(%rsi,%rdi,8)
movq 0x10(%rdx), %rsi
movq %rax, (%rsi,%rcx,8)
movq 0x8(%rbx), %rax
movb $0x0, 0x1(%rax)
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x91249
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8ecf1
movq 0x8(%rbx), %rax
leaq 0xb5300(%rip), %rcx     # 0x146550
movq %rcx, 0x48(%rax)
movq 0x8(%rbx), %rax
movb $0x1, 0x2(%rax)
movq $0x0, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: token
static token_t token(s7_scheme *sc) /* inline here is slower */
                {
                    int32_t c;
                    c = port_read_white_space(sc->input_port)(sc, sc->input_port);
                    switch (c)
                    {
                        case '(':  return(TOKEN_LEFT_PAREN);
                        case ')':  return(TOKEN_RIGHT_PAREN);
                        case '.':  return(read_dot(sc, sc->input_port));
                        case '\'': return(TOKEN_QUOTE);
                        case ';':  return(port_read_semicolon(sc->input_port)(sc, sc->input_port));
                        case '"':  return(TOKEN_DOUBLE_QUOTE);
                        case '`':  return(TOKEN_BACK_QUOTE);
                        case ',':  return(read_comma(sc, sc->input_port));
                        case '#':  return(read_sharp(sc, sc->input_port));
                        case '\0':
                        case EOF:  return(TOKEN_EOF);
                        default:
                                   sc->strbuf[0] = (unsigned char)c; /* every TOKEN_ATOM return goes to port_read_name, so we save a backchar/inchar shuffle by starting the read here */
                                   return(TOKEN_ATOM);
                    }
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x170(%rdi), %rsi
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
callq *0x20(%rax)
cmpl $0x3a, %eax
jg 0x912a4
leal -0x22(%rax), %ecx
cmpl $0xc, %ecx
ja 0x912b5
leaq 0x76c58(%rip), %rdx     # 0x107eec
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x6, %eax
jmp 0x912f4
cmpl $0x3b, %eax
je 0x91313
cmpl $0x60, %eax
jne 0x912c1
movl $0x7, %eax
jmp 0x912f4
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x912c1
xorl %eax, %eax
jmp 0x912f4
movq 0x4b0(%rbx), %rcx
movb %al, (%rcx)
movl $0x4, %eax
jmp 0x912f4
movq 0x170(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x91387
movl $0x2, %eax
jmp 0x912f4
movl $0x5, %eax
jmp 0x912f4
movl $0x1, %eax
popq %rbx
retq
movq 0x170(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x913ce
movq 0x170(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x9132c
movq 0x170(%rbx), %rsi
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq 0x18(%rax), %rax
movq %rbx, %rdi
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: read_dot
static token_t read_dot(s7_scheme *sc, s7_pointer pt)
                {
                    int32_t c;
                    c = inchar(pt);
                    if (c != EOF)
                    {
                        backchar(c, pt);
                        if ((!char_ok_in_a_name[c]) && (c != 0))
                            return(TOKEN_DOT);
                    }
                    else
                    {
                        sc->strbuf[0] = '.';
                        return(TOKEN_DOT);
                    }
                    sc->strbuf[0] = '.';
                    return(TOKEN_ATOM);  /* i.e. something that can start with a dot like a number */
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x91aef
cmpl $-0x1, %eax
je 0x91371
movl %eax, %ebp
movsbl %bpl, %edi
movq %r14, %rsi
callq 0xfb07
movl $0x4, %ecx
testl %ebp, %ebp
je 0x91376
movslq %ebp, %rdx
leaq 0xc46fc(%rip), %rsi     # 0x155a60
movl $0x3, %eax
cmpb $0x0, (%rdx,%rsi)
je 0x91382
jmp 0x91376
movl $0x3, %ecx
movq 0x4b0(%rbx), %rax
movb $0x2e, (%rax)
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: inchar
static int32_t inchar(s7_pointer pt)
    {
        int32_t c;
        if (is_file_port(pt))
            c = fgetc(port_file(pt)); /* not uint8_t! -- could be EOF */
        else
        {
            if (port_data_size(pt) <= port_position(pt))
                return(EOF);
            c = (uint8_t)port_data(pt)[port_position(pt)++];
        }

        if (c == '\n')
            port_line_number(pt)++;

        return(c);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0x0, 0x4(%rax)
je 0x91b1e
movq 0x20(%rbx), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, 0x18(%rbx)
jle 0x91b38
movq 0x10(%rbx), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rbx)
movzbl (%rax,%rcx), %eax
jmp 0x91b27
movq 0x8(%rax), %rdi
callq 0x8290
cmpl $0xa, %eax
jne 0x91b38
movq 0x8(%rbx), %rax
incl 0x20(%rax)
movl $0xa, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: nan2_or_bust
static s7_pointer nan2_or_bust(s7_scheme *sc, s7_double x, char *p, char *q, int32_t radix, bool want_symbol)
    {
        char *ip;
        s7_pointer rl;
        s7_int len;
        len = safe_strlen(q);
        ip = copy_string_with_length((const char *)q, len - 7);
        rl = make_atom(sc, ip, radix, false, false);
        free(ip);
        if (s7_is_real(rl))
            return(make_complex(sc, real_to_double(sc, rl, __func__), x));
        return((want_symbol) ? make_symbol(sc, q) : sc->F);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
movsd %xmm0, (%rsp)
je 0x92d9c
cmpb $0x0, (%r14)
je 0x92d9c
movq $-0x7, %r12
cmpb $0x0, 0x8(%r14,%r12)
leaq 0x1(%r12), %r12
jne 0x92d78
leaq 0x1(%r12), %rdi
callq 0x8480
movq %rax, %r13
testq %r12, %r12
jne 0x92db2
xorl %r12d, %r12d
jmp 0x92dc0
movq $-0x6, %rdi
callq 0x8480
movq %rax, %r13
movq $-0x7, %r12
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x83e0
movb $0x0, (%r13,%r12)
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x91b3a
movq %rax, %r15
movq %r13, %rdi
callq 0x8050
movzbl (%r15), %eax
leaq 0xb7bc4(%rip), %rcx     # 0x14a9b0
cmpb $0x1, (%rax,%rcx)
jne 0x92e12
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x92e3c
jp 0x92e3c
cmpb $0xd, %al
jne 0x92e84
movsd 0x8(%r15), %xmm0
jmp 0x92e96
testb %bpl, %bpl
je 0x92e30
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9afc
movq 0x120(%rbx), %r14
jmp 0x92f00
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92e60
movq %rbx, %rdi
callq 0xa550
movsd (%rsp), %xmm1
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0xe, (%r14)
cmpb $0xd, (%r15)
jne 0x92edd
movsd 0x8(%r15), %xmm0
jmp 0x92ef4
leaq 0x83b01(%rip), %rdx     # 0x11698c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd498
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x92ebf
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xa550
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0xd, (%r14)
movsd %xmm0, 0x8(%r14)
jmp 0x92f00
leaq 0x83aa8(%rip), %rdx     # 0x11698c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd498
movsd (%rsp), %xmm1
movsd %xmm0, 0x8(%r14)
movsd %xmm1, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: unknown_sharp_constant
static s7_pointer unknown_sharp_constant(s7_scheme *sc, char *name)
    {
        if (hook_has_functions(sc->read_error_hook))  /* check *read-error-hook* */
        {
            s7_pointer result;
            /* see sc->error_hook for a more robust way to handle this */
            result = s7_call(sc, sc->read_error_hook, list_2(sc, sc->T, s7_make_string_wrapper(sc, name)));
            if (result != sc->unspecified)
                return(result);
        }
        return(make_unknown(sc, name));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x210(%rdi), %r15
movq 0x18e0(%rdi), %rsi
movq 0x18(%r15), %rdx
callq 0xbe9a
cmpb $0x1, (%rax)
jne 0x93b7e
testq %rbx, %rbx
je 0x93ac5
cmpb $0x0, (%rbx)
je 0x93ac5
xorl %ecx, %ecx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rbx,%rcx)
movq %rax, %rcx
jne 0x93ab5
jmp 0x93ac7
xorl %eax, %eax
movq 0x118(%r14), %r12
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %r13
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
movq %rbx, 0x10(%r13)
movq %rax, 0x8(%r13)
movq 0x90(%r14), %rax
movq 0x110(%r14), %rbp
cmpq 0x98(%r14), %rax
ja 0x93b1b
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%r14), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r12, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x43bf0
cmpq 0x130(%r14), %rax
je 0x93b7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x93b94
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: make_unknown
static s7_pointer make_unknown(s7_scheme *sc, const char* name)
    {
        s7_pointer p;
        char *newstr;
        s7_int len;
        new_cell(sc, p, T_UNDEFINED | T_IMMUTABLE);
        len = safe_strlen(name);
        newstr = (char *)malloc(len + 2); /* this is a non-permanent unknown */
        newstr[0] = '#';
        if (len > 0)
            memcpy((void *)(newstr + 1), (void *)name, len);
        newstr[len + 1] = '\0';
        if (sc->undefined_constant_warnings)
            s7_warn(sc, len + 32, "%s is undefined\n", newstr);
        unique_name_length(p) = len + 1;
        unknown_name(p) = newstr;
        add_unknown(sc, p);
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x93bc2
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x1000004, (%rbx)      # imm = 0x1000004
testq %r15, %r15
je 0x93bf6
cmpb $0x0, (%r15)
je 0x93bf6
xorl %eax, %eax
leaq 0x1(%rax), %r12
cmpb $0x0, 0x1(%r15,%rax)
movq %r12, %rax
jne 0x93be5
jmp 0x93bf9
xorl %r12d, %r12d
leaq 0x2(%r12), %rdi
callq 0x8480
movq %rax, %r13
movb $0x23, (%rax)
testq %r12, %r12
jle 0x93c1f
movq %r13, %rdi
incq %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x83e0
leaq 0x1(%r12), %r15
movb $0x0, 0x1(%r13,%r12)
cmpb $0x1, 0x218d(%r14)
jne 0x93c4f
addq $0x20, %r12
leaq 0x82d2f(%rip), %rdx     # 0x11696e
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rcx
xorl %eax, %eax
callq 0xeea2
movq %r15, 0x28(%rbx)
movq %r13, 0x20(%rbx)
movq 0x780(%r14), %r14
movq (%r14), %rax
movq 0x10(%r14), %rsi
cmpq 0x8(%r14), %rsi
jne 0x93c86
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%r14)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%r14)
movq 0x10(%r14), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%r14)
movq %rbx, (%rax,%rsi,8)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: resize_strbuf
static void resize_strbuf(s7_scheme *sc, s7_int needed_size)
    {
        s7_int i, old_size;
        old_size = sc->strbuf_size;
        while (sc->strbuf_size <= needed_size) sc->strbuf_size *= 2;
        sc->strbuf = (char *)realloc(sc->strbuf, sc->strbuf_size);
        for (i = old_size; i < sc->strbuf_size; i++) sc->strbuf[i] = '\0';
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq 0x4a8(%rdi), %r14
movq %r14, %rsi
cmpq %rax, %r14
jg 0x93cca
movq %r14, %rsi
addq %rsi, %rsi
cmpq %rax, %rsi
jle 0x93cbb
movq %rsi, 0x4a8(%rbx)
movq 0x4b0(%rbx), %rdi
callq 0x8510
movq %rax, 0x4b0(%rbx)
cmpq 0x4a8(%rbx), %r14
jge 0x93cf7
movq 0x4b0(%rbx), %rax
movb $0x0, (%rax,%r14)
incq %r14
jmp 0x93cdd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: file_read_semicolon
static token_t file_read_semicolon(s7_scheme *sc, s7_pointer pt)
    {
        int32_t c;
        do (c = fgetc(port_file(pt))); while ((c != '\n') && (c != EOF));
        port_line_number(pt)++;
        if (c == EOF)
            return(TOKEN_EOF);
        return(token(sc));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x8290
cmpl $0xa, %eax
je 0x93dd5
cmpl $-0x1, %eax
jne 0x93dbe
movq 0x8(%r14), %rcx
incl 0x20(%rcx)
cmpl $-0x1, %eax
je 0x93df0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9126a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: file_read_white_space
static int32_t file_read_white_space(s7_scheme *sc, s7_pointer port)
    {
        int32_t c;
        while (is_white_space(c = fgetc(port_file(port))))
            if (c == '\n')
                port_line_number(port)++;
        return(c);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xbe4c8(%rip), %r14     # 0x1522d0
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rdi
callq 0x8290
movslq %eax, %rcx
cmpb $0x1, (%r14,%rcx)
jne 0x93e49
cmpl $0xa, %eax
jne 0x93e2b
movq 0x8(%rbx), %rax
incl 0x20(%rax)
movq 0xbe49e(%rip), %r14     # 0x1522d0
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x8290
movslq %eax, %rcx
cmpb $0x0, (%r14,%rcx)
jne 0x93e1f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: close_input_file
static void close_input_file(s7_scheme *sc, s7_pointer p)
    {
        if (port_filename(p))
        {
            /* for string ports, this is the original input file name */
            liberate(sc, port_filename_block(p));
            port_filename(p) = NULL;
        }
        if (port_file(p))
        {
            fclose(port_file(p));
            port_file(p) = NULL;
        }
        if (port_needs_free(p))
            free_port_data(sc, p);

        port_port(p)->pf = &closed_port_functions;
        port_set_closed(p, true);
        port_position(p) = 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x940f1
movq 0x18(%rax), %r15
movslq 0x8(%r15), %rax
cmpq $0x11, %rax
jne 0x940cd
movq (%r15), %rdi
testq %rdi, %rdi
je 0x940bc
callq 0x8050
movq $0x0, (%r15)
movl $0x0, 0x8(%r15)
leaq 0x838(%r14), %rax
jmp 0x940d7
leaq (%r14,%rax,8), %rax
addq $0x838, %rax            # imm = 0x838
movq (%rax), %rcx
movq %rcx, 0x18(%r15)
movq %r15, (%rax)
movq 0x8(%rbx), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x9410f
callq 0x8180
movq 0x8(%rbx), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x94123
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8ecf1
movq 0x8(%rbx), %rax
leaq 0xb2426(%rip), %rcx     # 0x146550
movq %rcx, 0x48(%rax)
movq 0x8(%rbx), %rax
movb $0x1, 0x2(%rax)
movq $0x0, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: file_read_name_or_sharp
static s7_pointer file_read_name_or_sharp(s7_scheme *sc, s7_pointer pt, bool atom_case)
    {
        int32_t c;
        s7_int i = 1;
        /* sc->strbuf[0] has the first char of the string we're reading */

        do {
            c = fgetc(port_file(pt)); /* might return EOF */
            if (c == '\n')
                port_line_number(pt)++;

            sc->strbuf[i++] = (unsigned char)c;
            if (i >= sc->strbuf_size)
                resize_strbuf(sc, i);
        } while ((c != EOF) && (char_ok_in_a_name[c]));

        if ((i == 2) &&
                (sc->strbuf[0] == '\\'))
            sc->strbuf[2] = '\0';
        else
        {
            if (c != EOF)
            {
                if (c == '\n')
                    port_line_number(pt)--;
                ungetc(c, port_file(pt));
            }
            sc->strbuf[i - 1] = '\0';
        }

        if (atom_case)
            return(make_atom(sc, sc->strbuf, BASE_10, SYMBOL_OK, WITH_OVERFLOW_ERROR));

        return(make_sharp_constant(sc, sc->strbuf, WITH_OVERFLOW_ERROR));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq $-0x1, %rax
movl $0x2, %ecx
leaq 0xc18f4(%rip), %rbp     # 0x155a60
movq %rax, %r13
movq %rcx, %r12
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x8290
movl %eax, %r15d
cmpl $0xa, %eax
jne 0x9418e
movq 0x8(%r14), %rax
incl 0x20(%rax)
movq 0x4b0(%rbx), %rax
movb %r15b, -0x1(%rax,%r12)
cmpq 0x4a8(%rbx), %r12
jl 0x941ae
movq %rbx, %rdi
movq %r12, %rsi
callq 0x93c9f
cmpl $-0x1, %r15d
je 0x941c6
movslq %r15d, %rdx
leaq -0x1(%r13), %rax
leaq 0x1(%r12), %rcx
cmpb $0x0, (%rdx,%rbp)
jne 0x9416c
cmpq $0x2, %r12
jne 0x941de
movq 0x4b0(%rbx), %rax
cmpb $0x5c, (%rax)
jne 0x941de
addq $0x2, %rax
jmp 0x9420b
cmpl $-0x1, %r15d
je 0x94201
cmpl $0xa, %r15d
jne 0x941f1
movq 0x8(%r14), %rax
decl 0x20(%rax)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movl %r15d, %edi
callq 0x84c0
movq 0x4b0(%rbx), %rax
subq %r13, %rax
movb $0x0, (%rax)
movq 0x4b0(%rbx), %rsi
cmpb $0x0, 0x4(%rsp)
je 0x9423c
movq %rbx, %rdi
movl $0xa, %edx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x91b3a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9256e
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: file_write_char
static void file_write_char(s7_scheme *sc, uint8_t c, s7_pointer port)
    {
        if (port_position(port) == PORT_DATA_SIZE)
        {
            if (fwrite((void *)(port_data(port)), 1, PORT_DATA_SIZE, port_file(port)) != PORT_DATA_SIZE)
                s7_warn(sc, 64, "fwrite trouble during write-char\n");
            port_position(port) = 0;
        }
        port_data(port)[port_position(port)++] = c;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq 0x20(%rdx), %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x942d6
movq %rdi, %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdi
movq 0x8(%rax), %rcx
movl $0x1, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x8660
cmpq $0x100, %rax            # imm = 0x100
jne 0x942bd
xorl %r12d, %r12d
jmp 0x942d6
leaq 0x826d5(%rip), %rdx     # 0x116999
xorl %r12d, %r12d
movl $0x40, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0xeea2
movq 0x10(%r14), %rax
leaq 0x1(%r12), %rcx
movq %rcx, 0x20(%r14)
movb %bl, (%rax,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: file_write_string
static void file_write_string(s7_scheme *sc, const char *str, s7_int len, s7_pointer pt)
    {
        s7_int new_len;
        new_len = port_position(pt) + len;
        if (new_len >= PORT_DATA_SIZE)
        {
            if (port_position(pt) > 0)
            {
                if (fwrite((void *)(port_data(pt)), 1, port_position(pt), port_file(pt)) != (size_t)port_position(pt))
                    s7_warn(sc, 64, "fwrite trouble in write-string\n");
                port_position(pt) = 0;
            }
            if (fwrite((void *)str, 1, len, port_file(pt)) != (size_t)len)
                s7_warn(sc, 64, "fwrite trouble in write-string\n");
        }
        else
        {
            memcpy((void *)(port_data(pt) + port_position(pt)), (void *)str, len);
            port_position(pt) = new_len;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq 0x20(%rcx), %rdx
leaq (%rdx,%r14), %r13
cmpq $0x100, %r13            # imm = 0x100
jl 0x94394
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x94358
movq 0x8(%r15), %rax
movq 0x10(%r15), %rdi
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x8660
cmpq 0x20(%r15), %rax
je 0x94350
leaq 0x8267a(%rip), %rdx     # 0x1169bb
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xeea2
movq $0x0, 0x20(%r15)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x8660
cmpq %r14, %rax
je 0x943aa
leaq 0x8263f(%rip), %rdx     # 0x1169bb
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xeea2
addq 0x10(%r15), %rdx
movq %rdx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x83e0
movq %r13, 0x20(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: file_display
static void file_display(s7_scheme *sc, const char *s, s7_pointer port)
    {
        if (s)
        {
            if (port_position(port) > 0)
            {
                if (fwrite((void *)(port_data(port)), 1, port_position(port), port_file(port)) != (size_t)port_position(port))
                    s7_warn(sc, 64, "fwrite trouble in display\n");
                port_position(port) = 0;
            }
            if (fputs(s, port_file(port)) == EOF)
                s7_warn(sc, 64, "write to %s: %s\n", port_filename(port), strerror(errno));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x94440
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
jle 0x9442b
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdi
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x8660
cmpq 0x20(%r14), %rax
je 0x94423
leaq 0x825c7(%rip), %rdx     # 0x1169db
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xeea2
movq $0x0, 0x20(%r14)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x8250
cmpl $-0x1, %eax
je 0x94446
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rax
movq 0x10(%rax), %r14
callq 0x8090
movl (%rax), %edi
callq 0x86b0
leaq 0x82595(%rip), %rdx     # 0x1169f6
movl $0x40, %esi
movq %rbx, %rdi
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xeea2