LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_integer
s7_pointer s7_make_integer(s7_scheme *sc, s7_int n)
    {
        s7_pointer x;
        if (is_small(n))              /* ((n >= 0) && (n < NUM_SMALL_INTS)) is slower */
            return(small_int(n));

        new_cell(sc, x, T_INTEGER);
        integer(x) = n;
        return(x);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x7ff, %rsi            # imm = 0x7FF
ja 0xe015
leaq 0x140941(%rip), %rax    # 0x14e950
movq (%rax,%rbx,8), %rax
jmp 0xe051
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xe030
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_real
s7_pointer s7_make_real(s7_scheme *sc, s7_double n)
    {
        s7_pointer x;
        new_cell(sc, x, T_REAL);
        set_real(x, n);
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xe085
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_mutable_real
s7_pointer s7_make_mutable_real(s7_scheme *sc, s7_double n)
    {
        s7_pointer x;
        new_cell(sc, x, T_REAL | T_MUTABLE | T_IMMUTABLE);
        set_real(x, n);
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xe0d9
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xb389
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x500000d, (%rax)      # imm = 0x500000D
movsd %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_complex
s7_pointer s7_make_complex(s7_scheme *sc, s7_double a, s7_double b)
    {
        s7_pointer x;
        if (b == 0.0)
        {
            new_cell(sc, x, T_REAL);
            set_real(x, a);
        }
        else
        {
            new_cell(sc, x, T_COMPLEX);
            set_real_part(x, a);
            set_imag_part(x, b);
        }
        return(x);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
movq 0x90(%rdi), %rax
movq 0x98(%rdi), %rcx
jne 0xe15e
jp 0xe15e
cmpq %rcx, %rax
ja 0xe13a
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0xe1a8
cmpq %rcx, %rax
ja 0xe181
movq %rbx, %rdi
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0xb389
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xe, (%rax)
movsd %xmm0, 0x8(%rax)
movsd %xmm1, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_number_to_real_with_caller
s7_double s7_number_to_real_with_caller(s7_scheme *sc, s7_pointer x, const char *caller)
    {
        if (is_t_real(x))
            return(real(x));

        switch (type(x))
        {
            case T_INTEGER:     return((s7_double)integer(x));
            case T_RATIO:       return((s7_double)numerator(x) / (s7_double)denominator(x));
            case T_REAL:        return(real(x));
#if WITH_GMP
            case T_BIG_INTEGER: return((s7_double)big_integer_to_s7_int(big_integer(x)));
            case T_BIG_RATIO:   return((s7_double)((long_double)big_integer_to_s7_int(mpq_numref(big_ratio(x))) /
                                            (long_double)big_integer_to_s7_int(mpq_denref(big_ratio(x)))));
            case T_BIG_REAL:    return((s7_double)mpfr_get_d(big_real(x), GMP_RNDN));
#endif
        }
        s7_wrong_type_arg_error(sc, caller, 0, x, "a real number");
        return(0.0);
    }

// Assembly:
movq %rsi, %rcx
movzbl (%rsi), %eax
cmpl $0xb, %eax
je 0xe23e
cmpl $0xc, %eax
je 0xe22d
cmpl $0xd, %eax
jne 0xe245
movsd 0x8(%rcx), %xmm0
retq
cvtsi2sdq 0x8(%rcx), %xmm0
cvtsi2sdq 0x10(%rcx), %xmm1
divsd %xmm1, %xmm0
retq
cvtsi2sdq 0x8(%rcx), %xmm0
retq
pushq %rax
leaq 0x1064f4(%rip), %r8     # 0x114741
movq %rdx, %rsi
xorl %edx, %edx
callq 0xe25f
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_wrong_type_arg_error
s7_pointer s7_wrong_type_arg_error(s7_scheme *sc, const char *caller, s7_int arg_n, s7_pointer arg, const char *descr)
                {
                    if (arg_n > 0)
                        return(wrong_type_arg_error_prepackaged(sc, wrap_string(sc, caller, safe_strlen(caller)), wrap_integer1(sc, arg_n),
                                    arg, type_name_string(sc, arg), wrap_string(sc, descr, safe_strlen(descr))));
                    return(simple_wrong_type_arg_error_prepackaged(sc, wrap_string(sc, caller, safe_strlen(caller)), arg,
                                type_name_string(sc, arg), wrap_string(sc, descr, safe_strlen(descr))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
jle 0xe34c
testq %rsi, %rsi
je 0xe29b
cmpb $0x0, (%rsi)
je 0xe29b
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rsi,%rcx)
movq %rax, %rcx
jne 0xe28b
jmp 0xe29d
xorl %eax, %eax
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdi
movq (%rcx,%rdi,8), %r12
leal 0x1(%rdi), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
movq %rsi, 0x10(%r12)
movq %rax, 0x8(%r12)
movq 0x1f00(%r14), %rax
movq %rdx, 0x8(%rax)
movq 0x1f00(%r14), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x461ec
testq %r15, %r15
je 0xe306
cmpb $0x0, (%r15)
je 0xe306
movq $-0x1, %rdx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%r15,%rdx)
movq %rcx, %rdx
jne 0xe2f5
jmp 0xe308
xorl %ecx, %ecx
movq 0x820(%r14), %rdx
movslq 0x7dc(%r14), %rsi
movq (%rdx,%rsi,8), %r9
leal 0x1(%rsi), %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r14)
movq %r15, 0x10(%r9)
movq %rcx, 0x8(%r9)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq %rax, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb31d
testq %rsi, %rsi
je 0xe36d
cmpb $0x0, (%rsi)
je 0xe36d
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rsi,%rcx)
movq %rax, %rcx
jne 0xe35d
jmp 0xe36f
xorl %eax, %eax
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %r12
leal 0x1(%rdx), %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
movq %rsi, 0x10(%r12)
movq %rax, 0x8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x461ec
testq %r15, %r15
je 0xe3c6
cmpb $0x0, (%r15)
je 0xe3c6
movq $-0x1, %rdx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%r15,%rdx)
movq %rcx, %rdx
jne 0xe3b5
jmp 0xe3c8
xorl %ecx, %ecx
movq 0x820(%r14), %rdx
movslq 0x7dc(%r14), %rsi
movq (%rdx,%rsi,8), %r8
leal 0x1(%rsi), %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r14)
movq %r15, 0x10(%r8)
movq %rcx, 0x8(%r8)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_number_to_string
char *s7_number_to_string(s7_scheme *sc, s7_pointer obj, s7_int radix)
    {
        s7_int nlen = 0;
        block_t *b;
        char *str;
        b = number_to_string_with_radix(sc, obj, radix, 0, 20, 'g', &nlen);  /* (log top 10) so we get all the digits in base 10 (??) */
        str = copy_string_with_length((char *)block_data(b), nlen);
        liberate(sc, b);
        return(str);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %r15, (%rsp)
movl $0x14, %r8d
xorl %ecx, %ecx
movl $0x67, %r9d
callq 0xe55c
movq %rax, %r14
movq (%rax), %r12
movq (%r15), %r13
leaq 0x1(%r13), %rdi
callq 0x9480
movq %rax, %r15
testq %r13, %r13
je 0xe502
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x93e0
movb $0x0, (%r15,%r13)
movslq 0x8(%r14), %rax
cmpq $0x11, %rax
jne 0xe536
testq %r12, %r12
je 0xe525
movq %r12, %rdi
callq 0x9050
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
addq $0x838, %rbx            # imm = 0x838
jmp 0xe541
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: rationalize_p_d
s7_pointer rationalize_p_d(s7_scheme *sc, s7_double x)
    {
        if ((is_NaN(x)) || (is_inf(x)))
            return(out_of_range(sc, sc->rationalize_symbol, small_int(1), make_real(sc, x), a_normal_real_string));
        if ((x > 9.2233720368548e+18) || (x < -9.2233720368548e+18))
            return(out_of_range(sc, sc->rationalize_symbol, small_int(1), make_real(sc, x), its_too_large_string));
        return(s7_rationalize(sc, x, sc->default_rationalize_error));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xeea2
movq 0x1438(%rbx), %rax
movq 0x8(%rax), %r15
movq 0x13fb03(%rip), %r14    # 0x14e958
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xee77
movq %rbx, %rdi
movdqa %xmm0, (%rsp)
callq 0xb389
movdqa (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movq %xmm0, 0x8(%rax)
movq 0x143b98(%rip), %rcx    # 0x152a38
jmp 0xef19
movdqa 0x103f26(%rip), %xmm1   # 0x112dd0
pand %xmm0, %xmm1
ucomisd 0x10018a(%rip), %xmm1   # 0x10f040
jbe 0xef66
movq 0x1438(%rbx), %rax
movq 0x8(%rax), %r15
movq 0x13fa8a(%rip), %r14    # 0x14e958
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xeef0
movq %rbx, %rdi
movdqa %xmm0, (%rsp)
callq 0xb389
movdqa (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movq %xmm0, 0x8(%rax)
movq 0x143b27(%rip), %rcx    # 0x152a40
movq 0x1ee8(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq %r15, 0x8(%rdx)
movq 0x10(%rdx), %rdx
movq %r14, 0x8(%rdx)
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b366
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd 0x258(%rbx), %xmm1
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xd9fa
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_real_part
s7_double s7_real_part(s7_pointer x)
    {
        switch(type(x))
        {
            case T_INTEGER:     return((s7_double)integer(x));
            case T_RATIO:       return(fraction(x));
            case T_REAL:        return(real(x));
            case T_COMPLEX:     return(real_part(x));
#if WITH_GMP
            case T_BIG_INTEGER: return((s7_double)big_integer_to_s7_int(big_integer(x)));
            case T_BIG_RATIO:   return((s7_double)((long_double)big_integer_to_s7_int(mpq_numref(big_ratio(x))) / (long_double)big_integer_to_s7_int(mpq_denref(big_ratio(x)))));
            case T_BIG_REAL:    return((s7_double)mpfr_get_d(big_real(x), GMP_RNDN));
            case T_BIG_COMPLEX: return((s7_double)mpfr_get_d(mpc_realref(big_complex(x)), GMP_RNDN));
#endif
        }
        return(0.0);
    }

// Assembly:
movzbl (%rdi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xf008
leaq 0x1001e1(%rip), %rcx    # 0x10f1ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x8(%rdi), %xmm0
retq
cvtsi2sdq 0x8(%rdi), %xmm0
retq
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rax, -0x8(%rsp)
fildll -0x8(%rsp)
movq %rcx, -0x10(%rsp)
fildll -0x10(%rsp)
fdivrp %st, %st(1)
fstpl -0x18(%rsp)
movsd -0x18(%rsp), %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_random_state_to_list
s7_pointer s7_random_state_to_list(s7_scheme *sc, s7_pointer args)
    {
#define H_random_state_to_list "(random-state->list r) returns the random state object as a list.\
        You can later apply random-state to this list to continue a random number sequence from any point."
#define Q_random_state_to_list s7_make_signature(sc, 2, sc->is_pair_symbol, sc->is_random_state_symbol)

#if WITH_GMP
        if ((is_pair(args)) &&
                (!is_random_state(car(args))))
            return(method_or_bust_with_type(sc, car(args), sc->random_state_to_list_symbol, args, a_random_state_object_string, 1));
        return(sc->nil);
#else
        s7_pointer r;
        if (is_null(args))
            r = sc->default_rng;
        else
        {
            r = car(args);
            if (!is_random_state(r))
                return(method_or_bust_with_type(sc, r, sc->random_state_to_list_symbol, args, a_random_state_object_string, 1));
        }
        return(list_2(sc, make_integer(sc, random_seed(r)), make_integer(sc, random_carry(r))));
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, 0x110(%rdi)
je 0xf2c4
movq %rsi, %rcx
movq 0x8(%rsi), %r14
cmpb $0x24, (%r14)
je 0xf2cb
movq 0x1428(%rbx), %rdx
movq 0x1437a6(%rip), %r8     # 0x152a50
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3da
movq 0xaa0(%rbx), %r14
movq 0x8(%r14), %r13
leaq 0x13f67a(%rip), %r12    # 0x14e950
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0xf2e5
movq (%r12,%r13,8), %r15
jmp 0xf31e
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xf2fd
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0xb, (%r15)
movq %r13, 0x8(%r15)
movq 0x10(%r14), %r13
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0xf331
movq (%r12,%r13,8), %r14
jmp 0xf36a
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xf349
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0xb, (%r14)
movq %r13, 0x8(%r14)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xf389
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rax), %rax
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %rcx, 0x10(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_set_default_random_state
void s7_set_default_random_state(s7_scheme *sc, s7_int seed, s7_int carry)
    {
#if (!WITH_GMP)
        s7_pointer p;
        new_cell(sc, p, T_RANDOM_STATE);
        random_seed(p) = (uint64_t)seed;
        random_carry(p) = (uint64_t)carry;
        sc->default_rng = p;
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xf4c4
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x24, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0xaa0(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_string_with_length
static inline s7_pointer make_string_with_length(s7_scheme *sc, const char *str, s7_int len)
    {
        s7_pointer x;
        new_cell(sc, x, T_STRING | T_SAFE_PROCEDURE);
        string_block(x) = mallocate(sc, len + 1);
        string_value(x) = (char *)block_data(string_block(x));
        if (len > 0)
            memcpy((void *)string_value(x), (void *)str, len);
        string_value(x)[len] = 0;
        string_length(x) = len;
        string_hash(x) = 0;
        add_string(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xf649
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200013, (%rbx)       # imm = 0x200013
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xa305
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testq %r15, %r15
jle 0xf68d
movq %r12, %rsi
movq %r15, %rdx
callq 0x93e0
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r15)
movq %r15, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x738(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0xf6ca
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_empty_string
static s7_pointer make_empty_string(s7_scheme *sc, s7_int len, char fill)
    {
        s7_pointer x;
        block_t *b;
        new_cell(sc, x, T_STRING);
        b = mallocate(sc, len + 1);                   /* terminated_string_read_white_space needs the second #\null (is this still the case?) */
        string_block(x) = b;
        string_value(x) = (char *)block_data(b);
        if ((fill != '\0') && (len > 0))
            local_memset((void *)(string_value(x)), fill, len);
        string_value(x)[len] = 0;
        string_hash(x) = 0;
        string_length(x) = len;
        add_string(sc, x);
        return(x);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xf862
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x13, (%rbx)
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0xa305
movq %rax, 0x20(%rbx)
movq (%rax), %rdi
movq %rdi, 0x10(%rbx)
testb %bpl, %bpl
sete %al
testq %r15, %r15
setle %cl
orb %al, %cl
jne 0xf8e6
movzbl %bpl, %esi
cmpq $0x8, %r15
jb 0xf8d9
movq %r15, %rax
shrq $0x3, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rsi, %rcx
movq %rcx, (%rdi)
addq $0x8, %rdi
decq %rax
jne 0xf8c5
movl %r15d, %edx
andl $0x7, %edx
jmp 0xf8dc
movq %r15, %rdx
testq %rdx, %rdx
je 0xf8e6
callq 0x9270
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r15)
movq $0x0, 0x18(%rbx)
movq %r15, 0x8(%rbx)
movq 0x738(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0xf923
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_permanent_string
s7_pointer s7_make_permanent_string(s7_scheme *sc, const char *str)
    {
        /* for the symbol table which is never GC'd */
        s7_pointer x;
        x = alloc_pointer(sc);
#if S7_DEBUGGING
        permanent_strings++;
#endif
        set_type(x, T_STRING | T_IMMUTABLE | T_UNHEAP);
        if (str)
        {
            s7_int len;
            len = safe_strlen(str);
            string_length(x) = len;
            /* string_block(x) = mallocate_block(); */
            string_block(x) = NULL;
            string_value(x) = (char *)alloc_permanent_string(sc, len + 1);
            memcpy((void *)string_value(x), (void *)str, len);
            string_value(x)[len] = 0;
        }
        else
        {
            string_value(x) = NULL;
            string_length(x) = 0;
        }
        string_hash(x) = 0;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xfa3b
movq %rax, %rbx
movabsq $0x4000000001000013, %rax # imm = 0x4000000001000013
movq %rax, (%rbx)
testq %r14, %r14
je 0xf98b
cmpb $0x0, (%r14)
je 0xf997
movq $-0x1, %rax
leaq 0x1(%rax), %r12
cmpb $0x0, 0x1(%r14,%rax)
movq %r12, %rax
jne 0xf97a
jmp 0xf99a
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0xfa26
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x8(%r12), %rcx
movq %rcx, %r13
andq $-0x8, %r13
movq 0x8c8(%r15), %rax
addq %r13, %rax
cmpq $0x10001, %rax          # imm = 0x10001
jb 0xf9f9
cmpq $0x200, %rcx            # imm = 0x200
jb 0xf9da
movq %r13, %rdi
callq 0x9480
movq %rax, %rdi
jmp 0xfa0e
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, 0x8d0(%r15)
movq $0x0, 0x8c8(%r15)
movq %r13, %rax
movq 0x8d0(%r15), %rdi
addq 0x8c8(%r15), %rdi
movq %rax, 0x8c8(%r15)
movq %rdi, 0x10(%rbx)
movq %r14, %rsi
movq %r12, %rdx
callq 0x93e0
movq 0x10(%rbx), %rax
movb $0x0, (%rax,%r12)
movq $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: alloc_pointer
static s7_cell *alloc_pointer(s7_scheme *sc)
    {
        if (sc->alloc_pointer_k == ALLOC_POINTER_SIZE)     /* if either no current block or the block is used up, make a new block */
        {
            sc->permanent_cells += ALLOC_POINTER_SIZE;
            sc->alloc_pointer_cells = (s7_cell *)calloc(ALLOC_POINTER_SIZE, sizeof(s7_cell));
            sc->alloc_pointer_k = 0;
        }
        return(&(sc->alloc_pointer_cells[sc->alloc_pointer_k++]));
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x100, 0x7f0(%rdi)     # imm = 0x100
jne 0xfa75
addl $0x100, 0x7d8(%rbx)     # imm = 0x100
movl $0x100, %edi            # imm = 0x100
movl $0x30, %esi
callq 0x9360
movq %rax, 0x800(%rbx)
movl $0x0, 0x7f0(%rbx)
movl 0x7f0(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x7f0(%rbx)
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq 0x800(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_port_filename
const char *s7_port_filename(s7_scheme *sc, s7_pointer x)
    {
        if (((is_input_port(x)) ||
                    (is_output_port(x))) &&
                (!port_is_closed(x)))
            return(port_filename(x));
        return(NULL);
    }

// Assembly:
movb (%rsi), %al
andb $-0x2, %al
cmpb $0x22, %al
jne 0xfb4c
movq 0x8(%rsi), %rax
cmpb $0x0, 0x2(%rax)
je 0xfb4f
xorl %eax, %eax
retq
movq 0x10(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_flush_output_port
void s7_flush_output_port(s7_scheme *sc, s7_pointer p)
    {
        if ((!is_output_port(p)) ||
                (!is_file_port(p)) ||
                (port_is_closed(p)) ||
                (p == sc->F))
            return;

        if (port_file(p))
        {
            if (port_position(p) > 0)
            {
                if (fwrite((void *)(port_data(p)), 1, port_position(p), port_file(p)) != (size_t)port_position(p))
                    s7_warn(sc, 64, "fwrite trouble in flush-output-port\n");
                port_position(p) = 0;
            }
            fflush(port_file(p));
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x22, (%rsi)
jne 0xfc35
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpl $0x0, 0x4(%rax)
jne 0xfc35
cmpb $0x0, 0x2(%rax)
jne 0xfc35
movq %rdi, %r14
cmpq %rbx, 0x120(%rdi)
je 0xfc35
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0xfc35
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
jle 0xfc21
movq 0x10(%rbx), %rdi
movl $0x1, %esi
callq 0x9660
cmpq 0x20(%rbx), %rax
je 0xfc19
leaq 0x103366(%rip), %rdx    # 0x112f70
movl $0x40, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0xfc3d
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9490
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_warn
static void s7_warn(s7_scheme *sc, s7_int len, const char *ctrl, ...) /* len = max size of output string (for vsnprintf) */
                {
                    if (sc->error_port != sc->F)
                    {
                        va_list ap;
                        s7_pointer warning;
                        char *str;

                        warning = make_empty_string(sc, len, 0);
                        string_value(warning)[0] = '\0';
                        str = (char *)string_value(warning);
                        va_start(ap, ctrl);
                        vsnprintf(str, len, ctrl, ap);
                        va_end(ap);

                        if (port_is_closed(sc->error_port))
                            sc->error_port = sc->standard_error;
                        s7_display(sc, warning, sc->error_port);
                    }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xfc8b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x190(%rdi), %rax
cmpq 0x120(%rdi), %rax
je 0xfd24
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %edx, %edx
callq 0xf83b
movq %rax, %r15
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movq 0x10(%r15), %rdi
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rsp, %rcx
movq %rax, (%rcx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rcx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rcx)
movq %r12, %rsi
movq %r14, %rdx
callq 0x9130
movq 0x190(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0x1, 0x2(%rax)
jne 0xfd12
movq 0x1d8(%rbx), %rax
movq %rax, 0x190(%rbx)
movq 0x190(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a587
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: file_error
static s7_pointer file_error(s7_scheme *sc, const char *caller, const char *descr, const char *name)
                {
                    return(s7_error(sc, sc->io_error_symbol,
                                set_elist_4(sc, wrap_string(sc, "~A: ~A ~S", 9),
                                    s7_make_string_wrapper(sc, caller),
                                    s7_make_string_wrapper(sc, descr),
                                    s7_make_string_wrapper(sc, name))));
                }

// Assembly:
movq %rsi, %rax
movq 0x1930(%rdi), %rsi
movq 0x820(%rdi), %r8
movslq 0x7dc(%rdi), %r9
movq (%r8,%r9,8), %r8
incl %r9d
andl $0x7, %r9d
movl %r9d, 0x7dc(%rdi)
leaq 0x1102be(%rip), %r9     # 0x1204d0
movq %r9, 0x10(%r8)
movq $0x9, 0x8(%r8)
testq %rax, %rax
je 0x10240
cmpb $0x0, (%rax)
je 0x10240
movq $-0x1, %r9
leaq 0x1(%r9), %r10
cmpb $0x0, 0x1(%rax,%r9)
movq %r10, %r9
jne 0x1022f
jmp 0x10243
xorl %r10d, %r10d
movq 0x820(%rdi), %r9
movslq 0x7dc(%rdi), %r11
movq (%r9,%r11,8), %r9
incl %r11d
andl $0x7, %r11d
movl %r11d, 0x7dc(%rdi)
movq %rax, 0x10(%r9)
movq %r10, 0x8(%r9)
testq %rdx, %rdx
je 0x1028c
cmpb $0x0, (%rdx)
je 0x1028c
movq $-0x1, %rax
leaq 0x1(%rax), %r10
cmpb $0x0, 0x1(%rdx,%rax)
movq %r10, %rax
jne 0x1027c
jmp 0x1028f
xorl %r10d, %r10d
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r11
movq (%rax,%r11,8), %rax
incl %r11d
andl $0x7, %r11d
movl %r11d, 0x7dc(%rdi)
movq %rdx, 0x10(%rax)
movq %r10, 0x8(%rax)
testq %rcx, %rcx
je 0x102d9
cmpb $0x0, (%rcx)
je 0x102d9
movq $-0x1, %r10
leaq 0x1(%r10), %rdx
cmpb $0x0, 0x1(%rcx,%r10)
movq %rdx, %r10
jne 0x102c8
jmp 0x102db
xorl %edx, %edx
movq 0x820(%rdi), %r10
movslq 0x7dc(%rdi), %r11
movq (%r10,%r11,8), %r10
incl %r11d
andl $0x7, %r11d
movl %r11d, 0x7dc(%rdi)
movq %rcx, 0x10(%r10)
movq %rdx, 0x8(%r10)
movq 0x6f0(%rdi), %rcx
movq %r8, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %r9, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %r10, 0x8(%rax)
movq 0x6f0(%rdi), %rdx
jmp 0x3b366
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mallocate_port
static block_t *mallocate_port(s7_scheme *sc)
    {
#define PORT_LIST 8 /* sizeof(port_t): 160 */
        block_t *p;
        p = sc->block_lists[PORT_LIST];
        if (p)
        {
            sc->block_lists[PORT_LIST] = (block_t *)block_next(p);
            /* block_next(p) = NULL; */
        }
        else
        { /* this is mallocate without the index calc */
            p = mallocate_block(sc);
            block_data(p) = (void *)alloc_permanent_string(sc, (size_t)(1 << PORT_LIST));
            block_set_index(p, PORT_LIST);
        }
        block_set_size(p, sizeof(port_t));
        return(p);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x878(%rdi), %r14
testq %r14, %r14
je 0x10355
movq 0x18(%r14), %rax
movq %rax, 0x878(%rbx)
jmp 0x1040d
cmpq $0x0, 0x838(%rbx)
jne 0x1039b
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%rbx)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x10379
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%rbx), %r14
movq 0x18(%r14), %rax
movq %rax, 0x838(%rbx)
movl $0x0, 0x8(%r14)
movl $0x100, %ecx            # imm = 0x100
movq 0x8c8(%rbx), %rax
addq %rcx, %rax
cmpq $0x10001, %rax          # imm = 0x10001
jb 0x103ed
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, 0x8d0(%rbx)
movq $0x0, 0x8c8(%rbx)
movl $0x100, %eax            # imm = 0x100
movq 0x8d0(%rbx), %rcx
addq 0x8c8(%rbx), %rcx
movq %rax, 0x8c8(%rbx)
movq %rcx, (%r14)
movl $0x8, 0x8(%r14)
movq $0x60, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: open_input_string
static s7_pointer open_input_string(s7_scheme *sc, const char *input_string, s7_int len)
    {
        s7_pointer x;
        block_t *b;
        new_cell(sc, x, T_INPUT_PORT);
        b = mallocate_port(sc);
        port_block(x) = b;
        port_port(x) = (port_t *)block_data(b);
        port_type(x) = STRING_PORT;
        port_set_closed(x, false);
        port_original_input_string(x) = sc->nil;
        port_data(x) = (uint8_t *)input_string;
        port_data_block(x) = NULL;
        port_data_size(x) = len;
        port_position(x) = 0;
        port_filename_block(x) = NULL;
        port_filename_length(x) = 0;
        port_filename(x) = NULL;
        port_file_number(x) = 0;
        port_line_number(x) = 0;
        port_needs_free(x) = false;
        port_needs_unprotect(x) = false;
#if S7_DEBUGGING
        if (input_string[len] != '\0')
        {
            fprintf(stderr, "read_white_space string is not terminated: %s", input_string);
            abort();
        }
#endif
        port_port(x)->pf = &input_string_functions;
        add_input_string_port(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x1046e
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x23, (%rbx)
movq %r14, %rdi
callq 0x10332
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x1, 0x4(%rax)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movb %cl, 0x2(%rax)
movq 0x110(%r14), %rax
movq 0x8(%rbx), %rdx
movq %rax, 0x40(%rdx)
movq %r12, 0x10(%rbx)
movq 0x8(%rbx), %rax
movq %rcx, 0x38(%rax)
movq %r15, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq 0x8(%rbx), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rbx), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rbx), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rbx), %rax
movb %cl, (%rax)
movq 0x8(%rbx), %rax
movb %cl, 0x1(%rax)
movq 0x8(%rbx), %rax
leaq 0x13e091(%rip), %rcx    # 0x14e5a0
movq %rcx, 0x48(%rax)
movq 0x758(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x1053b
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_open_input_function
s7_pointer s7_open_input_function(s7_scheme *sc, s7_pointer (*function)(s7_scheme *sc, s7_read_t read_choice, s7_pointer port))
    {
        s7_pointer x;
        block_t *b;
        new_cell(sc, x, T_INPUT_PORT);
        b = mallocate_port(sc);
        port_block(x) = b;
        port_port(x) = (port_t *)block_data(b);
        port_type(x) = FUNCTION_PORT;
        port_set_closed(x, false);
        port_original_input_string(x) = sc->nil;
        port_data_block(x) = NULL;
        port_needs_free(x) = false;
        port_filename_block(x) = NULL;
        port_filename(x) = NULL;
        port_filename_length(x) = 0;
        port_file_number(x) = 0;
        port_line_number(x) = 0;
        port_input_function(x) = function;
        port_port(x)->pf = &input_function_functions;
        add_input_port(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x1069a
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x23, (%rbx)
movq %r14, %rdi
callq 0x10332
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x2, 0x4(%rax)
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movb %cl, 0x2(%rax)
movq 0x110(%r14), %rax
movq 0x8(%rbx), %rdx
movq %rax, 0x40(%rdx)
movq 0x8(%rbx), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rbx), %rax
movb %cl, (%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rbx), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rbx), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rbx), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rbx), %rax
movq %r15, 0x50(%rax)
movq 0x8(%rbx), %rax
leaq 0x13dce0(%rip), %rcx    # 0x14e410
movq %rcx, 0x48(%rax)
movq 0x748(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x1075c
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_open_output_function
s7_pointer s7_open_output_function(s7_scheme *sc, void (*function)(s7_scheme *sc, uint8_t c, s7_pointer port))
    {
        s7_pointer x;
        block_t *b;
        new_cell(sc, x, T_OUTPUT_PORT);
        b = mallocate_port(sc);
        port_block(x) = b;
        port_port(x) = (port_t *)block_data(b);
        port_type(x) = FUNCTION_PORT;
        port_data(x) = NULL;
        port_data_block(x) = NULL;
        port_set_closed(x, false);
        port_needs_free(x) = false;
        port_output_function(x) = function;
        port_port(x)->pf = &output_function_functions;
        add_output_port(sc, x);
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x1079b
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x22, (%rbx)
movq %r14, %rdi
callq 0x10332
movq %rax, 0x28(%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movl $0x2, 0x4(%rax)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rcx
movq %rax, 0x38(%rcx)
movq 0x8(%rbx), %rcx
movb %al, 0x2(%rcx)
movq 0x8(%rbx), %rcx
movb %al, (%rcx)
movq 0x8(%rbx), %rax
movq %r15, 0x58(%rax)
movq 0x8(%rbx), %rax
leaq 0x13dc60(%rip), %rcx    # 0x14e460
movq %rcx, 0x48(%rax)
movq 0x750(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x1082c
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_peek_char
s7_pointer s7_peek_char(s7_scheme *sc, s7_pointer port)
    {
        int32_t c;              /* needs to be an int32_t so EOF=-1, but not 255 */
        if (is_string_port(port))
        {
            if (port_data_size(port) <= port_position(port))
                return(chars[EOF]);
            return(chars[(uint8_t)port_data(port)[port_position(port)]]);
        }
        c = port_read_character(port)(sc, port);
        if (c == EOF) return(eof_object);
        backchar(c, port);
        return(chars[c]);
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpl $0x1, 0x4(%rax)
jne 0x108c7
movq 0x20(%rbx), %rcx
movq 0x1421a5(%rip), %rax    # 0x152a58
cmpq %rcx, 0x18(%rbx)
jle 0x108f3
movq 0x10(%rbx), %rdx
movzbl (%rdx,%rcx), %ecx
leaq (%rax,%rcx,8), %rax
jmp 0x10900
movq 0x48(%rax), %rax
movq %rbx, %rsi
callq *(%rax)
cmpl $-0x1, %eax
je 0x108f9
movl %eax, %ebp
movsbl %bpl, %edi
movq %rbx, %rsi
callq 0x1090a
movslq %ebp, %rax
shlq $0x3, %rax
addq 0x142167(%rip), %rax    # 0x152a58
jmp 0x10900
addq $-0x8, %rax
jmp 0x10900
leaq 0x13de60(%rip), %rax    # 0x14e760
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: backchar
static void backchar(char c, s7_pointer pt)
    {
        if (c == '\n')
            port_line_number(pt)--;

        if (is_file_port(pt))
            ungetc(c, port_file(pt));
        else
        {
            if (port_position(pt) > 0)
                port_position(pt)--;
        }
    }

// Assembly:
cmpb $0xa, %dil
jne 0x10917
movq 0x8(%rsi), %rax
decl 0x20(%rax)
movq 0x8(%rsi), %rax
cmpl $0x0, 0x4(%rax)
je 0x10932
movq 0x20(%rsi), %rax
testq %rax, %rax
jle 0x10931
decq %rax
movq %rax, 0x20(%rsi)
retq
movq 0x8(%rax), %rsi
jmp 0x94c0
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: expand_cwd
static FILE *expand_cwd(s7_scheme *sc, const char *fname)
    {
        /* catch one special case, "~/..." since it causes 99.9% of the "can't load ..." errors */
        if ((fname[0] == '~') &&
                (fname[1] == '/'))
        {
            char *home;
            home = getenv("HOME");
            if (home)
            {
                block_t *b;
                char *filename;
                s7_int len;
                FILE *fp;

                len = safe_strlen(fname) + safe_strlen(home) + 1;
                b = mallocate(sc, len);
                filename = (char *)block_data(b);
                filename[0] = '\0';
                catstrs(filename, len, home, (char *)(fname + 1), NULL);
                fp = fopen(filename, "r");
                liberate(sc, b);

                return(fp);
            }
        }
        return(NULL);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x7e, (%rsi)
jne 0x37c68
movq %rsi, %r12
cmpb $0x2f, 0x1(%rsi)
jne 0x37c68
movq %rdi, %rbx
leaq 0xe7b80(%rip), %rdi     # 0x11f715
callq 0x9030
movq %rax, %r14
testq %rax, %rax
je 0x37bd2
leaq 0x1(%r12), %r15
xorl %eax, %eax
cmpb $0x0, (%r12,%rax)
leaq 0x1(%rax), %rax
jne 0x37ba9
cmpb $0x0, (%r14)
je 0x37bd7
movq $-0x1, %rcx
leaq 0x1(%rcx), %r13
cmpb $0x0, 0x1(%r14,%rcx)
movq %r13, %rcx
jne 0x37bc1
jmp 0x37bda
jmp 0x37c63
xorl %r13d, %r13d
addq %rax, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa305
movq %rax, %r12
movq (%rax), %rbp
movb $0x0, (%rbp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xa4d7
leaq 0xeb828(%rip), %rsi     # 0x123437
movq %rbp, %rdi
callq 0x95b0
movq %rax, %r15
movslq 0x8(%r12), %rax
cmpq $0x11, %rax
jne 0x37c4d
movq (%r12), %rdi
testq %rdi, %rdi
je 0x37c3b
callq 0x9050
movq $0x0, (%r12)
movl $0x0, 0x8(%r12)
addq $0x838, %rbx            # imm = 0x838
jmp 0x37c58
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r12)
movq %r12, (%rbx)
testq %r14, %r14
jne 0x37c6b
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: open_file_with_load_path
static FILE *open_file_with_load_path(s7_scheme *sc, const char *fname)
    {
        block_t *b;
        b = search_load_path(sc, fname);
        if (b)
        {
            FILE *fp;
            fp = fopen((const char *)block_data(b), "r");
            if ((fp) && (hook_has_functions(sc->load_hook)))
                s7_apply_function(sc, sc->load_hook, list_1(sc, sc->temp6 = s7_make_string(sc, (const char *)block_data(b))));
            liberate(sc, b);
            return(fp);
        }
        return(NULL);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9b323
testq %rax, %rax
je 0x37d6a
movq %rax, %r14
movq (%rax), %rdi
leaq 0xeb791(%rip), %rsi     # 0x123437
callq 0x95b0
movq %rax, %r15
testq %rax, %rax
je 0x37d3b
movq 0x1e8(%rbx), %r12
movq 0x18e0(%rbx), %rsi
movq 0x18(%r12), %rdx
movq %rbx, %rdi
callq 0xcd2c
cmpb $0x1, (%rax)
jne 0x37d3b
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xf735
movq %rax, %r13
movq %rax, 0x520(%rbx)
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x37d0b
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r13, 0x8(%rdx)
movq %rbp, 0x10(%rdx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbd41
movslq 0x8(%r14), %rax
cmpq $0x11, %rax
jne 0x37d6f
movq (%r14), %rdi
testq %rdi, %rdi
je 0x37d59
callq 0x9050
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
addq $0x838, %rbx            # imm = 0x838
jmp 0x37d7a
xorl %r15d, %r15d
jmp 0x37d84
leaq (%rbx,%rax,8), %rbx
addq $0x838, %rbx            # imm = 0x838
movq (%rbx), %rax
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: read_scheme_file
static s7_pointer read_scheme_file(s7_scheme *sc, FILE *fp, const char *fname)
    {
        s7_pointer port;
        port = read_file(sc, fp, fname, -1, "load");             /* -1 means always read its contents into a local string */
        port_file_number(port) = remember_file_name(sc, fname);
        set_loader_port(port);
        sc->temp6 = port;
        push_input_port(sc, port);
        sc->temp6 = sc->nil;
        return(port);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
leaq 0xe435b(%rip), %r8      # 0x11c103
movq $-0x1, %rcx
callq 0x96848
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9b619
movq 0x8(%r14), %rcx
movl %eax, 0x24(%rcx)
orb $0x4, 0x2(%r14)
movq %r14, 0x520(%rbx)
movl 0x180(%rbx), %esi
cmpl %esi, 0x184(%rbx)
jb 0x37e02
addl %esi, %esi
movl %esi, 0x180(%rbx)
movq 0x178(%rbx), %rdi
shlq $0x3, %rsi
callq 0x9510
movq %rax, 0x178(%rbx)
movq 0x170(%rbx), %rax
movq 0x178(%rbx), %rcx
movl 0x184(%rbx), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x184(%rbx)
movq %rax, (%rcx,%rdx,8)
movq %r14, 0x170(%rbx)
movq 0x110(%rbx), %rax
movq %rax, 0x520(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_add_to_load_path
s7_pointer s7_add_to_load_path(s7_scheme *sc, const char *dir)
    {
        s7_symbol_set_value(sc,
                sc->load_path_symbol,
                cons(sc,
                    s7_make_string(sc, dir),
                    s7_symbol_value(sc, sc->load_path_symbol)));
        return(s7_symbol_value(sc, sc->load_path_symbol));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1280(%rdi), %r14
callq 0xf735
movq %rax, %r15
movq 0x1280(%rbx), %rsi
movq %rbx, %rdi
callq 0xaa24
movq %rax, %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x388ae
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %r15, 0x8(%rdx)
movq %r12, 0x10(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcdac
movq 0x1280(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaa24
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_autoload
s7_pointer s7_autoload(s7_scheme *sc, s7_pointer symbol, s7_pointer file_or_function)
    {
        /* add '(symbol . file) to s7's autoload table */
        if (is_null(sc->autoload_table))
            sc->autoload_table = s7_make_hash_table(sc, sc->default_hash_table_length);
        if (sc->safety >= MORE_SAFETY_WARNINGS)
        {
            s7_pointer p;
            p = s7_hash_table_ref(sc, sc->autoload_table, symbol);
            if ((p != sc->F) && (p != file_or_function))
                s7_warn(sc, 256, "'%s autoload value changed\n", symbol_name(symbol));
        }
        s7_hash_table_set(sc, sc->autoload_table, symbol, file_or_function);
        return(file_or_function);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2140(%rdi), %rax
cmpq 0x110(%rdi), %rax
jne 0x38a9e
movq 0x270(%r15), %rsi
movq %r15, %rdi
callq 0x38b06
movq %rax, 0x2140(%r15)
cmpq $0x2, 0x6a0(%r15)
jl 0x38ae8
movq 0x2140(%r15), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq *0x18(%rsi)
movq 0x20(%rax), %rax
cmpq %rbx, %rax
je 0x38ae8
cmpq 0x120(%r15), %rax
je 0x38ae8
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
leaq 0xda4ea(%rip), %rdx     # 0x112fc3
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
xorl %eax, %eax
callq 0xfc3d
movq 0x2140(%r15), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x38db7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_eval_c_string_with_environment
s7_pointer s7_eval_c_string_with_environment(s7_scheme *sc, const char *str, s7_pointer e)
    {
        s7_pointer code, port, result;
        TRACK(sc);
        push_stack(sc, OP_GC_PROTECT, sc->args, sc->code);
        /* maybe this should just use locals? (GC protection is not the issue here),
         *   but this is way down in the noise -- read/eval below are 99% of the computing
         */
        port = s7_open_input_string(sc, str);
        code = s7_read(sc, port);
        s7_close_input_port(sc, port);
        result = s7_eval(sc, T_Pos(code), e);
        pop_stack(sc);
        return(result);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rdi)
callq 0x10420
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1093b
movq %rax, %r12
movq 0x8(%r15), %rax
movq 0x48(%rax), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x48(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x39527
movq 0x50(%rbx), %rcx
leaq -0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movups -0x20(%rcx), %xmm0
movups -0x10(%rcx), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq