LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
leal -0x11(%rdx), %eax
cmpl $-0xf, %eax
jae 0x73a2d
xorl %r14d, %r14d
jmp 0x73ae8
movq %rdi, %rbx
movl 0xa5ff2(%rip), %eax     # 0x119a28
shlq $0x3f, %rax
cmpq %rsi, %rax
jne 0x73a67
movl %edx, %eax
leaq 0xa12b8(%rip), %rcx     # 0x114d00
movq (%rcx,%rax,8), %r15
movq %r15, %rdi
callq 0x8d06
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x83e0
jmp 0x73ae3
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
movl %edx, %edi
xorl %r8d, %r8d
movq %rcx, %rax
leaq 0x1(%r8), %r9
cmpq $0x63, %r9
ja 0x73a92
cmpq %rdi, %rax
jl 0x73a92
xorl %edx, %edx
divq %rdi
movq %r9, %r8
jmp 0x73a79
xorl %r9d, %r9d
testq %rsi, %rsi
setns %r9b
negq %r9
testq %rsi, %rsi
js 0x73aa8
xorl %esi, %esi
jmp 0x73aae
movb $0x2d, (%rbx)
pushq $0x1
popq %rsi
leaq (%r9,%r8), %r10
leaq 0x74727(%rip), %r11     # 0xe81e0
leaq 0x1(%r10), %rax
cmpq %rsi, %rax
jl 0x73adb
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movb (%rdx,%r11), %cl
movb %cl, 0x1(%rbx,%r10)
decq %r10
movq %rax, %rcx
jmp 0x73ab9
leaq (%r9,%r8), %r14
addq $0x2, %r14
movb $0x0, (%rbx,%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0xa5f31(%rip), %eax     # 0x119a28
shlq $0x3f, %rax
cmpq %rsi, %rax
jne 0x73b09
leaq 0x6eb11(%rip), %rdi     # 0xe2618
jmp 0x73b53
movb $0x0, 0xb2f(%rdi)
addq $0xb2e, %rdi            # imm = 0xB2E
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
leaq 0x6e9b8(%rip), %r8      # 0xe24e0
pushq $0xa
popq %r9
movq %rcx, %rax
xorl %edx, %edx
divq %r9
movb (%rdx,%r8), %dl
movb %dl, (%rdi)
decq %rdi
cmpq $0x9, %rcx
movq %rax, %rcx
ja 0x73b2c
testq %rsi, %rsi
js 0x73b50
incq %rdi
jmp 0x73b53
movb $0x2d, (%rdi)
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa5e97(%rip), %eax     # 0x119a28
shlq $0x3f, %rax
cmpq %rsi, %rax
jne 0x73bad
leaq 0x6ea77(%rip), %r8      # 0xe2618
movabsq $0x14, %r10
jmp 0x73c2b
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
movabsq $-0x1, %r11
xorl %r10d, %r10d
leaq 0x6e8fd(%rip), %rbx     # 0xe24e0
movabsq $0xa, %r14
movq %r9, %rax
xorl %edx, %edx
divq %r14
movb (%rdx,%rbx), %dl
movb %dl, 0x1(%rdi,%r11)
incq %r10
decq %r11
cmpq $0x9, %r9
movq %rax, %r9
ja 0x73bed
testq %rsi, %rsi
popq %rbx
popq %r14
js 0x73c19
subq %r10, %r8
jmp 0x73c2b
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_O2/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 0x73c5b
movq 0x830(%r14), %rax
jmp 0x73c7b
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
pushq $0x20
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8270
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: floatify
static inline char *floatify(char *str, s7_int *nlen)
    {
        if ((!strchr(str, '.')) && (!strchr(str, 'e'))) /* faster than (strcspn(str, ".e") >= (size_t)(*nlen)) */
        {
            s7_int len;
            len = *nlen;
            /* snprintf returns "nan" and "inf" but we (stupidly) want "+nan.0" and "+inf.0"; "-nan" and "-inf" will be handled by the normal case */
            if (len == 3)
            {
                if (str[0] == 'n')
                {
                    str[0] = '+'; str[1] = 'n'; str[2] = 'a'; str[3] = 'n';
                    len = 4;
                }
                if (str[0] == 'i')
                {
                    str[0] = '+'; str[1] = 'i'; str[2] = 'n'; str[3] = 'f';
                    len = 4;
                }
            }
            str[len]='.';
            str[len + 1]='0';
            str[len + 2]='\0';
            (*nlen) = len + 2;
        }
        return(str);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2e
popq %rsi
callq 0x81d0
testq %rax, %rax
jne 0x73d20
pushq $0x65
popq %rsi
movq %rbx, %rdi
callq 0x81d0
testq %rax, %rax
jne 0x73d20
movq (%r14), %rax
cmpq $0x3, %rax
jne 0x73d0e
movzbl (%rbx), %eax
cmpl $0x6e, %eax
je 0x73cf7
cmpl $0x69, %eax
jne 0x73d0b
movb $0x66, %dl
movb $0x6e, %cl
jmp 0x73cfb
movb $0x61, %cl
movl %eax, %edx
movb $0x2b, (%rbx)
movb %al, 0x1(%rbx)
movb %cl, 0x2(%rbx)
movb %dl, 0x3(%rbx)
pushq $0x4
jmp 0x73d0d
pushq $0x3
popq %rax
movw $0x302e, (%rbx,%rax)    # imm = 0x302E
movb $0x0, 0x2(%rbx,%rax)
addq $0x2, %rax
movq %rax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: dtoa_round_digit
static void dtoa_round_digit(char* digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa, uint64_t frac)
    {
        while ((rem < frac) && (delta - rem >= kappa) &&
                ((rem + kappa < frac) || (frac - rem > rem + kappa - frac)))
        {
            digits[ndigits - 1]--;
            rem += kappa;
        }
    }

// Assembly:
movslq %esi, %rax
subq %rcx, %rdx
movq %r8, %rsi
subq %r9, %rsi
movq %r9, %r10
subq %rcx, %r10
cmpq %r9, %rcx
jae 0x73dc8
subq %r8, %rdx
jb 0x73dc8
leaq (%rcx,%r8), %r11
cmpq %r9, %r11
jb 0x73dbc
addq %rsi, %rcx
cmpq %rcx, %r10
jbe 0x73dc8
decb -0x1(%rdi,%rax)
subq %r8, %r10
movq %r11, %rcx
jmp 0x73da1
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x888f
cmpq 0x128(%rbx), %rax
je 0x73e04
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa34c
movq 0x1950(%rbx), %rsi
movq 0xad4ae(%rip), %rax     # 0x1212c0
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 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0xa
popq %rsi
movq %r15, %rdi
callq 0x81d0
testq %rax, %rax
je 0x741ae
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 0x7456a
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_O2/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
leaq (%rax,%rcx), %rdx
movq 0xad0f9(%rip), %rdi     # 0x1212d0
addq %rax, %rcx
incq %rcx
movzbl (%rdx), %eax
cmpb $0x1, (%rdi,%rax)
jne 0x741fa
cmpl $0xa, %eax
jne 0x741f2
movq 0x8(%rsi), %rax
incl 0x20(%rax)
incq %rdx
incq %rcx
jmp 0x741dd
testl %eax, %eax
je 0x74204
subq 0x10(%rsi), %rcx
jmp 0x74208
movq 0x18(%rsi), %rcx
movq %rcx, 0x20(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: string_read_name
static s7_pointer string_read_name(s7_scheme *sc, s7_pointer pt)
    {
        /* port_string was allocated (and read from a file) so we can mess with it directly */
        s7_pointer result;
        char *str;

        str = (char *)(port_data(pt) + port_position(pt));
        if (char_ok_in_a_name[(uint8_t)*str])
        {
            s7_int k;
            char endc;
            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) = port_data_size(pt);

            if (!number_table[(uint8_t)(*orig_str)])
                return(make_symbol_with_length(sc, orig_str, k));

            endc = (*str);
            (*str) = '\0';
            result = make_atom(sc, orig_str, BASE_10, SYMBOL_OK, WITH_OVERFLOW_ERROR);
            (*str) = endc;
            return(result);
        }
        result = sc->singletons[(uint8_t)(sc->strbuf[0])];
        if (!result)
        {
            sc->strbuf[1] = '\0';
            result = make_symbol_with_length(sc, sc->strbuf, 1);
            sc->singletons[(uint8_t)(sc->strbuf[0])] = result;
        }
        return(result);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x20(%rsi), %rcx
movzbl (%r15,%rcx), %edx
leaq 0xb0835(%rip), %rax     # 0x124a60
cmpb $0x1, (%rdx,%rax)
jne 0x74253
addq %rcx, %r15
xorl %r14d, %r14d
movzbl 0x1(%r15,%r14), %edx
incq %r14
cmpb $0x0, (%rdx,%rax)
jne 0x74237
leaq -0x1(%r15), %rax
testb %dl, %dl
je 0x7429a
addq %r14, %rcx
jmp 0x7429e
movq 0x488(%rbx), %rax
movq 0x4b0(%rbx), %rcx
movzbl (%rcx), %edx
movq (%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x742d0
movb $0x0, 0x1(%rcx)
movq 0x4b0(%rbx), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x8c3b
movq 0x488(%rbx), %rcx
movq 0x4b0(%rbx), %rdx
movzbl (%rdx), %edx
movq %rax, (%rcx,%rdx,8)
jmp 0x742d0
movq 0x18(%rsi), %rcx
movq %rcx, 0x20(%rsi)
movzbl (%rax), %ecx
leaq 0xb08b4(%rip), %rdx     # 0x124b60
cmpb $0x0, (%rcx,%rdx)
je 0x742db
movb (%r15,%r14), %bpl
movb $0x0, (%r15,%r14)
pushq $0xa
popq %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x74d92
movb %bpl, (%r15,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incq %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8c3b
// File: /workspace/github_c_makefile_star2_O2/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 0xb074e(%rip), %rcx     # 0x124a60
cmpb $0x1, (%rdx,%rcx)
jne 0x74385
addq %rax, %r14
pushq $0x1
popq %r15
movzbl (%r14,%r15), %edx
incq %r15
cmpb $0x0, (%rdx,%rcx)
jne 0x7431f
decq %r14
cmpb $0x1, %dl
adcq $-0x1, %rax
addq %r15, %rax
movq %rax, 0x20(%rsi)
leaq 0x1(%r15), %rsi
cmpq 0x4a8(%rbx), %rsi
jl 0x74353
movq %rbx, %rdi
callq 0x7697b
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 0x7578c
movq 0x4b0(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x743b4
cmpl $0x74, %ecx
je 0x743a7
cmpl $0x66, %ecx
jne 0x743c8
movq 0x120(%rbx), %rax
jmp 0x743ae
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 0x74371
movb $0x0, 0x1(%rax)
jmp 0x74371
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %ecx, %r14d
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, (%rsp)
movq 0x10(%rsi), %rbp
movq 0x20(%rsi), %r13
leaq (%rbp,%r13), %rbx
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x81d0
testq %rax, %rax
je 0x74430
movq 0x8(%r15), %rcx
incl 0x20(%rcx)
subq %rbp, %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r15)
testb %r12b, %r12b
cmovneq %rcx, %rax
subq %r13, %rax
testb %r14b, %r14b
je 0x7445c
movq (%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
jmp 0x74449
movq 0x18(%r15), %rdx
movq %rdx, 0x20(%r15)
subq %r13, %rdx
jle 0x74487
testb %r14b, %r14b
je 0x74490
movq (%rsp), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd11d
movq (%rsp), %rsi
movq 0x820(%rsi), %rcx
movslq 0x7dc(%rsi), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rsi)
movq %rbx, 0x10(%rcx)
movq %rax, 0x8(%rcx)
jmp 0x744ba
movq 0xa12d2(%rip), %rcx     # 0x115760
jmp 0x744ba
movq (%rsp), %rdi
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rsi
movq (%rax,%rsi,8), %rcx
leal 0x1(%rsi), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
movq %rbx, 0x10(%rcx)
movq %rdx, 0x8(%rcx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x74518
movq 0x18(%rax), %rsi
movq %r14, %rdi
callq 0x9439
movq 0x8(%rbx), %rax
andq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
cmpb $0x1, 0x1(%rax)
jne 0x74536
movq 0x28(%rax), %rsi
movq %r14, %rdi
callq 0x8b00
movq 0x8(%rbx), %rax
movb $0x0, 0x1(%rax)
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x7454a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x729df
movq 0x8(%rbx), %rax
leaq 0xa0fff(%rip), %rcx     # 0x115550
movq %rcx, 0x48(%rax)
movq 0x8(%rbx), %rax
movb $0x1, 0x2(%rax)
andq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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)
leal -0x22(%rax), %ecx
cmpl $0xc, %ecx
ja 0x7459c
leaq 0x5f93d(%rip), %rdx     # 0xd3ecc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
pushq $0x6
jmp 0x745dd
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x745b2
cmpl $0x3b, %eax
je 0x745fa
cmpl $0x60, %eax
jne 0x745b6
pushq $0x7
jmp 0x745dd
xorl %eax, %eax
jmp 0x745de
movq 0x4b0(%rbx), %rcx
movb %al, (%rcx)
pushq $0x4
jmp 0x745dd
pushq $0x1
jmp 0x745dd
movq 0x170(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x746a8
pushq $0x2
jmp 0x745dd
pushq $0x5
popq %rax
popq %rbx
retq
movq 0x170(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x74613
movq 0x170(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x74666
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_O2/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 0x74d4a
cmpl $-0x1, %eax
je 0x74654
movl %eax, %ebp
movsbl %bpl, %edi
movq %r14, %rsi
callq 0xdf3a
pushq $0x4
popq %rax
testl %ebp, %ebp
je 0x74657
movslq %ebp, %rcx
leaq 0xb0417(%rip), %rdx     # 0x124a60
cmpb $0x0, (%rcx,%rdx)
jne 0x74657
pushq $0x3
popq %rax
jmp 0x74661
pushq $0x3
popq %rax
movq 0x4b0(%rbx), %rcx
movb $0x2e, (%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74d74
movq 0x20(%rbx), %rax
cmpq %rax, 0x18(%rbx)
jle 0x74d8d
movq 0x10(%rbx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x20(%rbx)
movzbl (%rcx,%rax), %eax
jmp 0x74d7d
movq 0x8(%rax), %rdi
callq 0x8290
cmpl $0xa, %eax
jne 0x74d90
movq 0x8(%rbx), %rax
incl 0x20(%rax)
pushq $0xa
jmp 0x74d8f
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: nan1_or_bust
static s7_pointer nan1_or_bust(s7_scheme *sc, s7_double x, char *p, char *q, int32_t radix, bool want_symbol)
    {
        s7_int len;
        len = safe_strlen(p);
        if (p[len - 1] == 'i')        /* +nan.0[+/-]...i */
        {
            char *ip;
            s7_pointer imag;
            if (len == 6)            /* +nan.0+i */
                return(make_complex(sc, x, (p[4] == '+') ? 1.0 : -1.0));
            ip = copy_string_with_length((const char *)(p + 4), len - 5);
            imag = make_atom(sc, ip, radix, false, false);
            free(ip);
            if (s7_is_real(imag))
                return(make_complex(sc, x, real_to_double(sc, imag, __func__))); /* +nan.0+2/3i etc */
        }
        return((want_symbol) ? make_symbol(sc, q) : sc->F);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %r12
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8d06
cmpb $0x69, -0x1(%r12,%rax)
jne 0x75d08
addq $0x4, %r12
cmpq $0x6, %rax
jne 0x75cbe
xorl %eax, %eax
cmpb $0x2b, (%r12)
sete %al
leaq 0x602e8(%rip), %rcx     # 0xd5f50
movsd (%rcx,%rax,8), %xmm1
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x75c96
movq %rbx, %rdi
movsd %xmm1, (%rsp)
callq 0x9c27
movsd (%rsp), %xmm1
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xe, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd %xmm1, 0x10(%rax)
jmp 0x75d2b
addq $-0x5, %rax
movq %r12, %rdi
movq %rax, %rsi
callq 0xca33
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x74d92
movq %rax, %r15
movq %r12, %rdi
callq 0x8050
movzbl (%r15), %eax
leaq 0xa3cba(%rip), %rcx     # 0x1199b0
cmpb $0x1, (%rax,%rcx)
jne 0x75d08
cmpb $0xd, %al
jne 0x75d38
movsd 0x8(%r15), %xmm1
jmp 0x75d4e
testb %bpl, %bpl
je 0x75d24
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x94d4
movq 0x120(%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6cbe0(%rip), %rdx     # 0xe291f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc263
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movq 0x90(%rbx), %rax
movq 0x98(%rbx), %rcx
jne 0x75d9f
jp 0x75d9f
cmpq %rcx, %rax
ja 0x75d7c
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x75d2b
cmpq %rcx, %rax
jbe 0x75c7d
jmp 0x75c96
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8d06
leaq -0x7(%rax), %rsi
movq %r15, %rdi
callq 0xca33
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x74d92
movq %rax, %r14
movq %r12, %rdi
callq 0x8050
movzbl (%r14), %eax
leaq 0xa3ba9(%rip), %rcx     # 0x1199b0
cmpb $0x1, (%rax,%rcx)
jne 0x75e2b
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x75e53
jp 0x75e53
cmpb $0xd, %al
jne 0x75e96
movsd 0x8(%r14), %xmm0
jmp 0x75ea8
testb %bpl, %bpl
je 0x75e47
movq %rbx, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x94d4
movq 0x120(%rbx), %r15
jmp 0x75f15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x75e72
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0xe, (%r15)
cmpb $0xd, (%r14)
jne 0x75ef1
movsd 0x8(%r14), %xmm0
jmp 0x75f03
leaq 0x6ca8f(%rip), %rdx     # 0xe292c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc263
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x75ed3
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9c27
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0xd, (%r15)
movsd %xmm0, 0x8(%r15)
jmp 0x75f15
leaq 0x6ca34(%rip), %rdx     # 0xe292c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc263
movsd %xmm0, 0x8(%r15)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%r15)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15, %rsi
callq 0x97c7
cmpb $0x1, (%rax)
jne 0x7689f
movq 0x118(%r14), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd1ba
movq %rax, %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %rbp
cmpq 0x98(%r14), %rax
ja 0x7683c
movq %r14, %rdi
callq 0x9c27
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 %r12, 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 %r13, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x35e2b
cmpq 0x130(%r14), %rax
je 0x7689f
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 0x768b5
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x768e3
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x1000004, (%r14)      # imm = 0x1000004
movq %r15, %rdi
callq 0x8d06
movq %rax, %r13
leaq 0x2(%rax), %rdi
callq 0x8480
movq %rax, %r12
movb $0x23, (%rax)
testq %r13, %r13
jle 0x76929
movq %r12, %rdi
incq %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x83e0
leaq 0x1(%r13), %r15
movb $0x0, 0x1(%r12,%r13)
cmpb $0x1, 0x218d(%rbx)
jne 0x76957
addq $0x20, %r13
leaq 0x6bfc7(%rip), %rdx     # 0xe290e
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xd5c7
movq %r15, 0x28(%r14)
movq %r12, 0x20(%r14)
movq 0x780(%rbx), %rdi
movq %r14, %rsi
callq 0xb999
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rsi
jg 0x769a0
addq %rsi, %rsi
movq %rsi, 0x4a8(%rbx)
jmp 0x7698f
movq 0x4b0(%rbx), %rdi
callq 0x8510
movq %rax, 0x4b0(%rbx)
cmpq 0x4a8(%rbx), %r14
jge 0x769cd
movq 0x4b0(%rbx), %rax
movb $0x0, (%rax,%r14)
incq %r14
jmp 0x769b3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76aab
cmpl $-0x1, %eax
jne 0x76a94
movq 0x8(%r14), %rcx
incl 0x20(%rcx)
cmpl $-0x1, %eax
je 0x76ac6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7456a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xaa7f2(%rip), %r14     # 0x1212d0
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x8290
movslq %eax, %rcx
cmpb $0x1, (%r14,%rcx)
jne 0x76b03
cmpl $0xa, %eax
jne 0x76ad7
movq 0x8(%rbx), %rax
incl 0x20(%rax)
jmp 0x76ad7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: file_read_line
static s7_pointer file_read_line(s7_scheme *sc, s7_pointer port, bool with_eol, bool copied)
    {
        char *buf;
        s7_int read_size, previous_size = 0;

        if (!sc->read_line_buf)
        {
            sc->read_line_buf_size = 1024;
            sc->read_line_buf = (char *)malloc(sc->read_line_buf_size);
        }

        buf = sc->read_line_buf;
        read_size = sc->read_line_buf_size;

        while (true)
        {
            char *p, *rtn;
            size_t len;

            p = fgets(buf, read_size, port_file(port));
            if (!p)
                return(eof_object);

            rtn = strchr(buf, (int)'\n');
            if (rtn)
            {
                port_line_number(port)++;
                return(make_string_with_length(sc, sc->read_line_buf, (with_eol) ? (previous_size + rtn - p + 1) : (previous_size + rtn - p)));
            }
            /* if no newline, then either at eof or need bigger buffer */
            len = strlen(sc->read_line_buf);

            if ((len + 1) < (size_t)sc->read_line_buf_size)
                return(make_string_with_length(sc, sc->read_line_buf, len));

            previous_size = sc->read_line_buf_size;
            sc->read_line_buf_size *= 2;
            sc->read_line_buf = (char *)realloc(sc->read_line_buf, sc->read_line_buf_size);
            read_size = previous_size;
            previous_size -= 1;
            buf = (char *)(sc->read_line_buf + previous_size);
        }
        return(eof_object);
    }

// 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 0x4b8(%rdi), %r13
testq %r13, %r13
je 0x76b44
movq 0x4c0(%rbx), %r12
jmp 0x76b69
movq $0x400, 0x4c0(%rbx) # imm = 0x400
movl $0x400, %r12d           # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x8480
movq %rax, %r13
movq %rax, 0x4b8(%rbx)
xorl %ebp, %ebp
pushq $0xa
popq %r15
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdx
movq %r13, %rdi
movl %r12d, %esi
callq 0x8330
testq %rax, %rax
je 0x76be1
movq %rax, %r12
movq %r13, %rdi
movl %r15d, %esi
callq 0x81d0
testq %rax, %rax
jne 0x76bf7
movq 0x4b8(%rbx), %r13
movq %r13, %rdi
callq 0x81a0
leaq 0x1(%rax), %rcx
movq 0x4c0(%rbx), %r12
cmpq %r12, %rcx
jb 0x76c18
leaq (%r12,%r12), %rsi
movq %rsi, 0x4c0(%rbx)
movq %r13, %rdi
callq 0x8510
movq %rax, 0x4b8(%rbx)
leaq -0x1(%r12), %rbp
leaq (%rax,%r12), %r13
decq %r13
jmp 0x76b6f
movq 0x9eb78(%rip), %rax     # 0x115760
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rcx
incl 0x20(%rcx)
movq 0x4b8(%rbx), %rsi
addq %rbp, %rax
movzbl 0x4(%rsp), %edx
subq %r12, %rdx
addq %rax, %rdx
movq %rbx, %rdi
jmp 0x76c21
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd11d
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq $0x0, 0x10(%rax)
je 0x76c62
movq 0x18(%rax), %rsi
movq %r14, %rdi
callq 0x9439
movq 0x8(%rbx), %rax
andq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x76c7d
callq 0x8180
movq 0x8(%rbx), %rax
andq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rax
cmpb $0x1, (%rax)
jne 0x76c91
movq %r14, %rdi
movq %rbx, %rsi
callq 0x729df
movq 0x8(%rbx), %rax
leaq 0x9e8b8(%rip), %rcx     # 0x115550
movq %rcx, 0x48(%rax)
movq 0x8(%rbx), %rax
movb $0x1, 0x2(%rax)
andq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rax
pushq $0x2
popq %rcx
leaq 0xadd8d(%rip), %rbp     # 0x124a60
movq %rax, %r13
movq %rcx, %r12
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x8290
movl %eax, %r15d
cmpl $0xa, %eax
jne 0x76cf5
movq 0x8(%r14), %rax
incl 0x20(%rax)
movq 0x4b0(%rbx), %rax
movb %r15b, -0x1(%rax,%r12)
cmpq 0x4a8(%rbx), %r12
jl 0x76d15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7697b
cmpl $-0x1, %r15d
je 0x76d2d
movslq %r15d, %rdx
leaq -0x1(%r13), %rax
leaq 0x1(%r12), %rcx
cmpb $0x0, (%rdx,%rbp)
jne 0x76cd3
cmpq $0x2, %r12
jne 0x76d45
movq 0x4b0(%rbx), %rax
cmpb $0x5c, (%rax)
jne 0x76d45
addq $0x2, %rax
jmp 0x76d72
cmpl $-0x1, %r15d
je 0x76d68
cmpl $0xa, %r15d
jne 0x76d58
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 0x76d9f
pushq $0xa
popq %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x74d92
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7578c
// File: /workspace/github_c_makefile_star2_O2/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 0x76e35
movq %rdi, %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdi
movq 0x8(%rax), %rcx
pushq $0x1
popq %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x8660
cmpq $0x100, %rax            # imm = 0x100
jne 0x76e1e
xorl %r12d, %r12d
jmp 0x76e35
leaq 0x6bb14(%rip), %rdx     # 0xe2939
xorl %r12d, %r12d
pushq $0x40
popq %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0xd5c7
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_O2/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, %rbx
movq %rsi, %r12
movq 0x20(%rcx), %rdx
leaq (%rdx,%rbx), %r13
cmpq $0x100, %r13            # imm = 0x100
jl 0x76ee8
movq %rdi, %r14
testq %rdx, %rdx
jle 0x76eb0
movq 0x8(%r15), %rax
movq 0x10(%r15), %rdi
movq 0x8(%rax), %rcx
pushq $0x1
popq %rsi
callq 0x8660
cmpq 0x20(%r15), %rax
je 0x76eab
leaq 0x6babd(%rip), %rdx     # 0xe295b
pushq $0x40
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xd5c7
andq $0x0, 0x20(%r15)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rcx
pushq $0x1
popq %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x8660
cmpq %rbx, %rax
je 0x76efe
leaq 0x6ba89(%rip), %rdx     # 0xe295b
pushq $0x40
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd5c7
addq 0x10(%r15), %rdx
movq %rdx, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x83e0
movq %r13, 0x20(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76f8d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
jle 0x76f78
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdi
movq 0x8(%rax), %rcx
pushq $0x1
popq %rsi
callq 0x8660
cmpq 0x20(%r14), %rax
je 0x76f73
leaq 0x6ba15(%rip), %rdx     # 0xe297b
pushq $0x40
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd5c7
andq $0x0, 0x20(%r14)
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x8250
cmpl $-0x1, %eax
je 0x76f93
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rax
movq 0x10(%rax), %r14
callq 0x8090
movl (%rax), %edi
callq 0x86b0
leaq 0x6b9e8(%rip), %rdx     # 0xe2996
pushq $0x40
popq %rsi
movq %rbx, %rdi
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xd5c7