LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: stdin_read_line
static s7_pointer stdin_read_line(s7_scheme *sc, s7_pointer port, bool with_eol, bool copied)
    {
        if (!sc->read_line_buf)
        {
            sc->read_line_buf_size = 1024;
            sc->read_line_buf = (char *)malloc(sc->read_line_buf_size);
        }

        if (fgets(sc->read_line_buf, sc->read_line_buf_size, stdin))
            return(s7_make_string(sc, sc->read_line_buf)); /* fgets adds the trailing '\0' */
        return(make_string_with_length(sc, NULL, 0));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x4b8(%rdi)
jne 0x1028c8
movq $0x400, 0x4c0(%rbx) # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x9480
movq %rax, 0x4b8(%rbx)
movq 0x4b8(%rbx), %rdi
movl 0x4c0(%rbx), %esi
movq 0x4b6fc(%rip), %rax     # 0x14dfd8
movq (%rax), %rdx
callq 0x9330
testq %rax, %rax
je 0x1028fd
movq 0x4b8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf735
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x102915
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200013, (%r14)       # imm = 0x200013
movq 0x850(%rbx), %r15
testq %r15, %r15
je 0x10294e
movq 0x18(%r15), %rax
movq %rax, 0x850(%rbx)
jmp 0x102a02
cmpq $0x0, 0x838(%rbx)
jne 0x102994
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 0x102972
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%rbx), %r15
movq 0x18(%r15), %rax
movq %rax, 0x838(%rbx)
movl $0x0, 0x8(%r15)
movq 0x8c8(%rbx), %rax
addq $0x8, %rax
cmpq $0x10001, %rax          # imm = 0x10001
jb 0x1029e2
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, 0x8d0(%rbx)
movq $0x0, 0x8c8(%rbx)
movl $0x8, %eax
movq 0x8d0(%rbx), %rcx
addq 0x8c8(%rbx), %rcx
movq %rax, 0x8c8(%rbx)
movq %rcx, (%r15)
movl $0x3, 0x8(%r15)
movq $0x1, 0x10(%r15)
movq %r15, 0x20(%r14)
movq (%r15), %rax
movq %rax, 0x10(%r14)
movb $0x0, (%rax)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x18(%r14)
movq 0x738(%rbx), %rbx
movq 0x8(%rbx), %rsi
cmpq %rsi, 0x10(%rbx)
jne 0x102a4a
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movq %r14, (%rax,%rcx,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: find_dynamic_value
static s7_pointer find_dynamic_value(s7_scheme *sc, s7_pointer x, s7_pointer sym, int64_t *id)
    {
        for (; symbol_id(sym) < let_id(x); x = outlet(x));

        if (let_id(x) == symbol_id(sym))
        {
            (*id) = let_id(x);
            return(slot_value(local_slot(sym)));
        }
        for (; (is_let(x)) && (let_id(x) > (*id)); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == sym)
                {
                    (*id) = let_id(x);
                    return(slot_value(y));
                }
        }
        return(sc->unused);
    }

// Assembly:
movq 0x20(%rdx), %rax
movq 0x18(%rsi), %r8
cmpq %r8, %rax
jge 0x102f9d
movq 0x10(%rsi), %rsi
jmp 0x102f8e
cmpq %rax, %r8
jne 0x102faf
movq %r8, (%rcx)
movq 0x18(%rdx), %rdi
addq $0x10, %rdi
jmp 0x102ffd
cmpb $0x1c, (%rsi)
jne 0x102ff6
movq (%rcx), %r9
movq 0x18(%rsi), %r8
cmpq %r9, %r8
jle 0x102ff6
movq 0x8(%rsi), %r11
testq %r11, %r11
sete %r10b
je 0x102fd9
cmpq %rdx, 0x8(%r11)
je 0x102fde
movq 0x18(%r11), %r11
jmp 0x102fc4
movq %r9, %r8
jmp 0x102fe5
movq %r8, (%rcx)
movq 0x10(%r11), %rax
testb %r10b, %r10b
je 0x103000
movq 0x10(%rsi), %rsi
cmpb $0x1c, (%rsi)
movq %r8, %r9
je 0x102fb7
addq $0x140, %rdi            # imm = 0x140
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: open_and_protect_input_string
static inline s7_pointer open_and_protect_input_string(s7_scheme *sc, s7_pointer str)
    {
        s7_pointer p;
        p = open_input_string(sc, string_value(str), string_length(str));
        port_gc_loc(p) = s7_gc_protect_1(sc, str);
        port_needs_unprotect(p) = true;
        return(p);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rsi
callq 0x10445
movq %rax, %r15
cmpq $0x0, 0x108(%r14)
jns 0x103143
movq 0xd0(%r14), %rax
movq 0xf0(%r14), %r13
leaq (,%r13,2), %rbp
movq 0x18(%rax), %rsi
movq %r13, %r12
shlq $0x4, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0xae0f
movq $0x0, 0x20(%rax)
movq 0xd0(%r14), %rcx
movq %rax, 0x18(%rcx)
movq (%rax), %rax
movq 0xd0(%r14), %rcx
movq %rax, 0x10(%rcx)
movq 0xd0(%r14), %rax
movq %rbp, 0x8(%rax)
movq %rbp, 0xf0(%r14)
movq 0xe8(%r14), %rdi
movq %r12, %rsi
callq 0x9510
movq %rax, 0xe8(%r14)
cmpq %rbp, %r13
jge 0x103143
movq %r13, %rax
movq 0xd0(%r14), %rcx
movq 0x140(%r14), %rdx
movq 0x10(%rcx), %rcx
movq %rdx, (%rcx,%rax,8)
movq 0xe8(%r14), %rcx
movq 0x108(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x108(%r14)
movq %rax, 0x8(%rcx,%rdx,8)
incq %rax
decq %r13
jne 0x103107
movq 0xd0(%r14), %rax
movq 0xe8(%r14), %rcx
movq 0x108(%r14), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, 0x108(%r14)
movq (%rcx,%rdx,8), %rcx
movq 0x10(%rax), %rax
movq %rbx, (%rax,%rcx,8)
movq 0x8(%r15), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%r15), %rax
movb $0x1, 0x1(%rax)
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: input_port_if_not_loading
static s7_pointer input_port_if_not_loading(s7_scheme *sc)
    {
        s7_pointer port;
        port = sc->input_port;
        if (is_loader_port(port)) /* this flag is turned off by the reader macros, so we aren't in that context */
        {
            int32_t c;
            c = port_read_white_space(port)(sc, port);
            if (c > 0)            /* we can get either EOF or NULL at the end */
            {
                backchar(c, port);
                return(NULL);
            }
            return(sc->standard_input);
        }
        return(port);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x170(%rdi), %rbx
testb $0x4, 0x2(%rbx)
je 0x1031cd
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %rbx, %rsi
callq *0x20(%rax)
testl %eax, %eax
jle 0x1031c6
movsbl %al, %edi
movq %rbx, %rsi
callq 0x1090a
xorl %ebx, %ebx
jmp 0x1031cd
movq 0x1c8(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: call_with_input
static s7_pointer call_with_input(s7_scheme *sc, s7_pointer port, s7_pointer args)
    {
        s7_pointer p;
        p = cadr(args);
        port_original_input_string(port) = car(args);
        push_stack(sc, OP_UNWIND_INPUT, sc->input_port, port);
        push_stack(sc, OP_APPLY, list_1(sc, port), p);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rax
movq 0x10(%rdx), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rsi), %rdx
movq %rax, 0x40(%rdx)
movq 0x50(%rdi), %rax
movq %rsi, (%rax)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x50(%rdi), %rax
movq 0x170(%rdi), %rdx
movq %rdx, 0x10(%rax)
movq 0x50(%rdi), %rax
movq $0x1ee, 0x18(%rax)      # imm = 0x1EE
movq 0x50(%rdi), %rax
leaq 0x20(%rax), %rdx
movq %rdx, 0x50(%rdi)
movq %rcx, 0x20(%rax)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x90(%rdi), %rax
movq 0x110(%rdi), %r15
cmpq 0x98(%rdi), %rax
ja 0x103260
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x198, 0x18(%rax)      # imm = 0x198
addq $0x20, 0x50(%rbx)
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: with_input
static s7_pointer with_input(s7_scheme *sc, s7_pointer port, s7_pointer args)
    {
        s7_pointer old_input_port, p;
        old_input_port = sc->input_port;
        sc->input_port = port;
        port_original_input_string(port) = car(args);
        push_stack(sc, OP_UNWIND_INPUT, old_input_port, port);
        p = cadr(args);
        push_stack(sc, OP_APPLY, sc->nil, p);
        return(sc->F);
    }

// Assembly:
movq 0x170(%rdi), %rax
movq %rsi, 0x170(%rdi)
movq 0x8(%rdx), %rcx
movq 0x8(%rsi), %r8
movq %rcx, 0x40(%r8)
movq 0x50(%rdi), %rcx
movq %rsi, (%rcx)
movq 0x8(%rdi), %rcx
movq 0x50(%rdi), %rsi
movq %rcx, 0x8(%rsi)
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1ee, 0x18(%rax)      # imm = 0x1EE
movq 0x50(%rdi), %rax
leaq 0x20(%rax), %rcx
movq %rcx, 0x50(%rdi)
movq 0x10(%rdx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rdi), %rax
movq 0x110(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rdi), %rax
movq $0x198, 0x18(%rax)      # imm = 0x198
addq $0x20, 0x50(%rdi)
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_simple_ratio
static inline s7_pointer make_simple_ratio(s7_scheme *sc, s7_int num, s7_int den)
    {
        s7_pointer x;
        if (den == 1)
            return(make_integer(sc, num));
        if (den == -1)
            return(make_integer(sc, -num));
        if ((den == s7_int_min) && ((num & 1) != 0))
            return(make_real(sc, (long double)num / (long double)den));
        new_cell(sc, x, T_RATIO);
        if (den < 0)
        {
            numerator(x) = -num;
            denominator(x) = -den;
        }
        else
        {
            numerator(x) = num;
            denominator(x) = den;
        }
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $-0x1, %rdx
je 0x1033e1
movq %rdx, %r15
cmpq $0x1, %rdx
je 0x1033e4
testb $0x1, %bl
je 0x103438
movl 0x4f6bb(%rip), %eax     # 0x152a28
shlq $0x3f, %rax
cmpq %r15, %rax
jne 0x103438
movq %rbx, 0x10(%rsp)
fildll 0x10(%rsp)
movq %r15, 0x18(%rsp)
fildll 0x18(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x1033ba
movq %r14, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
movsd (%rsp), %xmm0
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0x103486
negq %rbx
cmpq $0x7ff, %rbx            # imm = 0x7FF
ja 0x1033fd
leaq 0x4b55c(%rip), %rax     # 0x14e950
movq (%rax,%rbx,8), %rax
jmp 0x103486
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x103415
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)
jmp 0x103486
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x103450
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xc, (%rax)
testq %r15, %r15
js 0x103478
movq %rbx, 0x8(%rax)
jmp 0x103482
negq %rbx
movq %rbx, 0x8(%rax)
negq %r15
movq %r15, 0x10(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: c_asin
static s7_pointer c_asin(s7_scheme *sc, s7_double x)
    {
        s7_double absx, recip;
        s7_complex result;

        absx = fabs(x);
        if (absx <= 1.0)
            return(make_real(sc, asin(x)));

        /* otherwise use maxima code: */
        recip = 1.0 / absx;
        result = (M_PI / 2.0) - (_Complex_I * clog(absx * (1.0 + (sqrt(1.0 + recip) * csqrt(1.0 - recip)))));
        if (x < 0.0)
            return(s7_from_c_complex(sc, -result));
        return(s7_from_c_complex(sc, result));
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movapd 0xf930(%rip), %xmm1     # 0x112dd0
andpd %xmm0, %xmm1
movsd 0xbb84(%rip), %xmm2     # 0x10f030
ucomisd %xmm1, %xmm2
jae 0x1034de
movapd %xmm0, 0x10(%rsp)
movapd %xmm2, %xmm3
movapd %xmm1, 0x30(%rsp)
divsd %xmm1, %xmm3
movapd %xmm3, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x10352f
sqrtsd %xmm0, %xmm0
jmp 0x103548
callq 0x9630
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x103507
movq %rbx, %rdi
movsd %xmm0, 0x10(%rsp)
callq 0xb389
movsd 0x10(%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 $0x40, %rsp
popq %rbx
retq
movsd %xmm3, 0x28(%rsp)
callq 0x9690
movsd 0x28(%rsp), %xmm3
movsd 0xbae8(%rip), %xmm2     # 0x10f030
movsd %xmm0, 0x8(%rsp)
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
callq 0x9560
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
addsd 0xbabb(%rip), %xmm0     # 0x10f030
movapd 0x30(%rsp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
callq 0x92a0
movapd %xmm0, %xmm2
movapd %xmm1, %xmm3
xorpd %xmm1, %xmm1
mulsd %xmm1, %xmm0
mulsd %xmm3, %xmm1
subsd %xmm3, %xmm0
addsd %xmm2, %xmm1
ucomisd %xmm0, %xmm0
jp 0x1035e5
movsd 0xbb06(%rip), %xmm2     # 0x10f0b8
subsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x1035cc
xorpd 0xf7f6(%rip), %xmm2     # 0x112dc0
jmp 0x1035d4
xorpd 0xf7ec(%rip), %xmm1     # 0x112dc0
movq %rbx, %rdi
movapd %xmm2, %xmm0
addq $0x40, %rsp
popq %rbx
jmp 0xe101
ucomisd %xmm1, %xmm1
jnp 0x1035aa
movsd 0xba3d(%rip), %xmm1     # 0x10f030
xorpd %xmm0, %xmm0
callq 0x10e760
jmp 0x1035aa
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: c_acos
static s7_pointer c_acos(s7_scheme *sc, s7_double x)
    {
        s7_double absx, recip;
        s7_complex result;

        absx = fabs(x);
        if (absx <= 1.0)
            return(make_real(sc, acos(x)));

        /* else follow maxima again: */
        recip = 1.0 / absx;
        if (x > 0.0)
            result = _Complex_I * clog(absx * (1.0 + (sqrt(1.0 + recip) * csqrt(1.0 - recip))));
        else result = M_PI - _Complex_I * clog(absx * (1.0 + (sqrt(1.0 + recip) * csqrt(1.0 - recip))));
        return(s7_from_c_complex(sc, result));
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movapd 0xf7c2(%rip), %xmm1     # 0x112dd0
andpd %xmm0, %xmm1
movsd 0xba16(%rip), %xmm2     # 0x10f030
ucomisd %xmm1, %xmm2
jae 0x10364c
movapd %xmm0, 0x10(%rsp)
movapd %xmm2, %xmm3
movapd %xmm1, 0x30(%rsp)
divsd %xmm1, %xmm3
movapd %xmm3, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x10369d
sqrtsd %xmm0, %xmm0
jmp 0x1036b6
callq 0x9320
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x103675
movq %rbx, %rdi
movsd %xmm0, 0x10(%rsp)
callq 0xb389
movsd 0x10(%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 $0x40, %rsp
popq %rbx
retq
movsd %xmm3, 0x28(%rsp)
callq 0x9690
movsd 0x28(%rsp), %xmm3
movsd 0xb97a(%rip), %xmm2     # 0x10f030
movsd %xmm0, 0x8(%rsp)
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
callq 0x9560
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
addsd 0xb94d(%rip), %xmm0     # 0x10f030
movapd 0x30(%rsp), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
callq 0x92a0
movapd %xmm0, %xmm2
movapd %xmm1, %xmm3
xorpd %xmm1, %xmm1
movapd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movapd %xmm2, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm3, %xmm1
subsd %xmm3, %xmm0
addsd %xmm2, %xmm1
jbe 0x103741
ucomisd %xmm0, %xmm0
jnp 0x10375f
ucomisd %xmm1, %xmm1
jnp 0x10375f
movsd 0xb8fa(%rip), %xmm1     # 0x10f030
xorpd %xmm0, %xmm0
callq 0x10e760
jmp 0x10375f
ucomisd %xmm0, %xmm0
jp 0x10376c
movsd 0xb9a9(%rip), %xmm2     # 0x10f0f8
subsd %xmm0, %xmm2
xorpd 0xf665(%rip), %xmm1     # 0x112dc0
movapd %xmm2, %xmm0
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0xe101
ucomisd %xmm1, %xmm1
jnp 0x103747
movsd 0xb8b6(%rip), %xmm1     # 0x10f030
xorpd %xmm0, %xmm0
callq 0x10e760
jmp 0x103747
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_truncate
static s7_pointer s7_truncate(s7_scheme *sc, s7_pointer caller, s7_double xf)   /* can't use "truncate" -- it's in unistd.h */
    {
        if ((xf > s7_int_max) ||
                (xf < s7_int_min))
            return(simple_out_of_range(sc, caller, wrap_real(sc, xf), its_too_large_string));

        if (xf > 0.0)
            return(make_integer(sc, (s7_int)floor(xf)));
        return(make_integer(sc, (s7_int)ceil(xf)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x4f474(%rip)     # 0x152c08
jne 0x10379c
xorpd %xmm1, %xmm1
jmp 0x1037a4
movsd 0xb87c(%rip), %xmm1     # 0x10f020
ucomisd %xmm1, %xmm0
ja 0x1037c7
cmpb $0x0, 0x4f277(%rip)     # 0x152a28
jne 0x1037b9
xorpd %xmm1, %xmm1
jmp 0x1037c1
movsd 0xb867(%rip), %xmm1     # 0x10f028
ucomisd %xmm0, %xmm1
jbe 0x103826
movq 0x8(%rsi), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0x4f254(%rip), %rsi     # 0x152a40
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ef8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b366
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x103837
callq 0x95f0
jmp 0x10383c
callq 0x96c0
cvttsd2si %xmm0, %r15
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0x103857
leaq 0x4b0ff(%rip), %rax     # 0x14e950
movq (%rax,%r15,8), %r14
jmp 0x10381d
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x10386f
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 %r15, 0x8(%r14)
jmp 0x10381d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: r5rs_round
static s7_double r5rs_round(s7_double x)
    {
        s7_double fl, ce, dfl, dce;

        fl = floor(x);
        ce = ceil(x);
        dfl = x - fl;
        dce = ce - x;

        if (dfl > dce) return(ce);
        if (dfl < dce) return(fl);
        if (fmod(fl, 2.0) == 0.0) return(fl);
        return(ce);
    }

// Assembly:
subq $0x28, %rsp
movsd %xmm0, (%rsp)
callq 0x95f0
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x96c0
movsd (%rsp), %xmm3
movapd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
subsd %xmm3, %xmm0
subsd %xmm2, %xmm3
ucomisd %xmm0, %xmm3
ja 0x10390a
ucomisd %xmm3, %xmm0
jbe 0x1038d8
movapd %xmm2, %xmm1
jmp 0x10390a
movapd %xmm1, (%rsp)
movsd 0xb83b(%rip), %xmm1     # 0x10f120
movapd %xmm2, %xmm0
callq 0x92c0
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movapd 0x10(%rsp), %xmm0
andpd %xmm1, %xmm0
andnpd (%rsp), %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: c_gcd
static s7_int c_gcd(s7_int u, s7_int v)
    {
        s7_int a, b;

        if ((u == s7_int_min) || (v == s7_int_min))
        {
            /* can't take abs of these (below) so do it by hand */
            s7_int divisor = 1;
            if (u == v) return(u);
            while (((u & 1) == 0) && ((v & 1) == 0))
            {
                u /= 2;
                v /= 2;
                divisor *= 2;
            }
            return(divisor);
        }

        a = s7_int_abs(u);
        b = s7_int_abs(v);
        /* there are faster gcd algorithms but does it ever matter? */
        while (b != 0)
        {
            s7_int temp;
            temp = a % b;
            a = b;
            b = temp;
        }
        /* if (a < 0) return(-a); */ /* why this? */
        return(a);
    }

// Assembly:
movl 0x4f10f(%rip), %eax     # 0x152a28
shlq $0x3f, %rax
cmpq %rdi, %rax
setne %cl
cmpq %rsi, %rax
setne %al
testb %al, %cl
jne 0x103937
cmpq %rsi, %rdi
jne 0x103962
movq %rdi, %rcx
jmp 0x103991
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
testq %rsi, %rsi
je 0x10398e
movq %rsi, %rdx
negq %rdx
cmovsq %rsi, %rdx
movq %rdx, %rcx
xorl %edx, %edx
divq %rcx
movq %rcx, %rax
testq %rdx, %rdx
jne 0x103950
jmp 0x103991
movl %edi, %eax
orl %esi, %eax
movl $0x1, %ecx
testb $0x1, %al
jne 0x103991
movq %rdi, %rax
movq %rsi, %rdx
sarq %rax
sarq %rdx
addq %rcx, %rcx
orl %esi, %edi
movq %rdx, %rsi
testb $0x2, %dil
movq %rax, %rdi
je 0x103975
jmp 0x103991
movq %rax, %rcx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: reduce_fraction
static int32_t reduce_fraction(s7_int *numer, s7_int *denom)
    {
        /* we're assuming in several places that we have a normal s7 rational after returning,
         *    so the denominator needs to be positive.
         */
        s7_int divisor;

        if (*numer == 0)
        {
            *denom = 1;
            return(T_INTEGER);
        }
        if (*denom < 0)
        {
            if (*denom == *numer)
            {
                *denom = 1;
                *numer = 1;
                return(T_INTEGER);
            }
            if (*denom == s7_int_min)
            {
                if (*numer & 1)
                    return(T_RATIO);
                *denom /= 2;
                *numer /= 2;
            }
            else
            {
                if (*numer == s7_int_min)
                {
                    if (*denom & 1)
                        return(T_RATIO);
                    *denom /= 2;
                    *numer /= 2;
                }
            }
            *denom = -*denom;
            *numer = -*numer;
        }
        divisor = c_gcd(*numer, *denom);
        if (divisor != 1)
        {
            *numer /= divisor;
            *denom /= divisor;
        }
        if (*denom == 1)
            return(T_INTEGER);
        return(T_RATIO);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x1039eb
movq %rdi, %r14
movq (%rbx), %rcx
testq %rcx, %rcx
js 0x1039f4
movq (%r14), %r15
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x103913
cmpq $0x1, %rax
je 0x1039dd
movq %rax, %rcx
movq %r15, %rax
cqto
idivq %rcx
movq %rax, (%r14)
movq (%rbx), %rax
cqto
idivq %rcx
movq %rax, (%rbx)
xorl %eax, %eax
cmpq $0x1, (%rbx)
setne %al
addl $0xb, %eax
jmp 0x103a09
movq $0x1, (%rbx)
jmp 0x103a04
cmpq %rdx, %rcx
jne 0x103a0f
movl $0x1, %eax
movq %rax, (%rbx)
movq %rax, (%r14)
movl $0xb, %eax
popq %rbx
popq %r14
popq %r15
retq
movl 0x4f013(%rip), %eax     # 0x152a28
shlq $0x3f, %rax
cmpq %rax, %rcx
jne 0x103a37
movl $0xc, %eax
testb $0x1, %dl
jne 0x103a09
movq %rcx, %rax
shrq $0x3f, %rax
addq %rcx, %rax
sarq %rax
jmp 0x103a4c
cmpq %rax, %rdx
jne 0x103a62
movl $0xc, %eax
testb $0x1, %cl
jne 0x103a09
sarq %rcx
movq %rcx, %rax
movq %rax, (%rbx)
movq (%r14), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
sarq %rcx
movq %rcx, (%r14)
negq (%rbx)
negq (%r14)
jmp 0x1039b0
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: multiply_method_or_bust
static s7_pointer multiply_method_or_bust(s7_scheme *sc, s7_pointer obj, s7_pointer caller, s7_pointer args, s7_pointer typ, int32_t num)
    {
        if (has_active_methods(sc, obj))
            return(find_and_apply_method(sc, find_let(sc, obj), sc->multiply_symbol, args));
        if (num == 0)
            return(simple_wrong_type_argument_with_type(sc, caller, obj, typ));
        return(wrong_type_argument_with_type(sc, caller, num, obj, typ));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rsi, %r14
movq %rdi, %r15
testb $0x40, 0x3(%rsi)
je 0x1047ef
cmpb $0x1, 0x24c(%r15)
jne 0x1047ef
movq %rcx, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x9a55
movq 0x1358(%r15), %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x967ca
movq 0x8(%rdx), %r12
testl %r9d, %r9d
je 0x104811
movslq %r9d, %r13
cmpl $0x7ff, %r9d            # imm = 0x7FF
ja 0x104832
leaq 0x4a145(%rip), %rax     # 0x14e950
movq (%rax,%r13,8), %rdx
jmp 0x10486b
movq 0x140(%r15), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfac8
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0x10484a
movq %r15, %rdi
callq 0xb389
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %r13, 0x8(%rdx)
movq 0x140(%r15), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb31d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: nan_with_error_check
static s7_pointer nan_with_error_check(s7_scheme *sc, s7_pointer y, s7_pointer p, s7_pointer args, s7_pointer caller)
    {
        for (; is_not_null(p); p = cdr(p))
            if (!is_real_via_method(sc, car(p)))
                return(wrong_type_argument(sc, caller, position_of(p, args), car(p), T_REAL));
        return(y);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
cmpq %rdx, 0x110(%rdi)
je 0x105192
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x4d853(%rip), %rbp     # 0x1529b0
movq 0x8(%r14), %rsi
movzbl (%rsi), %eax
cmpb $0x0, (%rax,%rbp)
jne 0x105185
testb $0x40, 0x3(%rsi)
je 0x1051a4
cmpb $0x1, 0x24c(%rbx)
jne 0x1051a4
movq %rbx, %rdi
callq 0x10523b
testb %al, %al
je 0x1051a4
movq 0x10(%r14), %r14
cmpq 0x110(%rbx), %r14
jne 0x10515d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
cmpq %r12, %r14
je 0x1051ba
incl %eax
movq 0x10(%r12), %r12
cmpq %r14, %r12
jne 0x1051ae
movq 0x8(%r15), %r15
movslq %eax, %r12
cmpl $0x7ff, %r12d           # imm = 0x7FF
ja 0x1051d7
leaq 0x4977f(%rip), %rax     # 0x14e950
movq (%rax,%r12,8), %rdx
jmp 0x105210
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x1051ef
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %r12, 0x8(%rdx)
movq 0x8(%r14), %rcx
movq 0x140(%rbx), %r8
movq 0x4d8a6(%rip), %r9      # 0x152ac8
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb31d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: c_quo_dbl
static s7_int c_quo_dbl(s7_scheme *sc, s7_double x, s7_double y)
    {
        s7_double xf;

        if (y == 0.0)
            division_by_zero_error(sc, sc->quotient_symbol, set_elist_2(sc, wrap_real(sc, x), wrap_real2(sc, y)));
        if ((is_inf(y)) || (is_NaN(y)))
            wrong_type_argument_with_type(sc, sc->quotient_symbol, 2, wrap_real(sc, y), a_normal_real_string);

        xf = x / y;
        if ((xf > s7_int_max) ||
                (xf < s7_int_min))
            simple_out_of_range(sc, sc->quotient_symbol, wrap_real(sc, xf), its_too_large_string);

        if (xf > 0.0)
            return((s7_int)floor(xf));
        return((s7_int)ceil(xf));
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
jne 0x105355
jp 0x105355
movq 0x1418(%rbx), %rsi
movq 0x1f18(%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq 0x1f18(%rbx), %rax
movq 0x1f20(%rbx), %rcx
movsd %xmm1, 0x8(%rcx)
movq 0x1f20(%rbx), %rcx
movq 0x6e0(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
callq 0xe1ae
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
movq %xmm1, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x1053b4
movq 0x1418(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x495e0(%rip), %rdx     # 0x14e960
movq 0x1f18(%rbx), %rax
movsd %xmm1, 0x8(%rax)
movq 0x1f18(%rbx), %rcx
movq 0x140(%rbx), %r8
movq 0x4d697(%rip), %r9      # 0x152a38
movq %rbx, %rdi
callq 0xb31d
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
cmpb $0x0, 0x4d849(%rip)     # 0x152c08
jne 0x1053c7
xorpd %xmm1, %xmm1
jmp 0x1053cf
movsd 0x9c51(%rip), %xmm1     # 0x10f020
ucomisd %xmm1, %xmm0
ja 0x1053f2
cmpb $0x0, 0x4d64c(%rip)     # 0x152a28
jne 0x1053e4
xorpd %xmm1, %xmm1
jmp 0x1053ec
movsd 0x9c3c(%rip), %xmm1     # 0x10f028
ucomisd %xmm0, %xmm1
jbe 0x105456
movq 0x1418(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0x4d622(%rip), %rsi     # 0x152a40
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ef8(%rbx), %rdx
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x3b366
movsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x105467
callq 0x95f0
jmp 0x10546c
callq 0x96c0
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: c_ash
static s7_int c_ash(s7_scheme *sc, s7_int arg1, s7_int arg2)
    {
        if (arg1 == 0) return(0);

        if (arg2 >= s7_int_bits)
        {
            if ((arg1 == -1) && (arg2 == 63))   /* (ash -1 63): most-negative-fixnum */
                return(s7_int_min);
            out_of_range(sc, sc->ash_symbol, small_int(2), wrap_integer1(sc, arg2), its_too_large_string);
        }

        if (arg2 < -s7_int_bits)
        {
            if (arg1 < 0)                      /* (ash -31 -100) */
                return(-1);
            return(0);
        }

        /* I can't see any point in protecting this: (ash 9223372036854775807 1) -> -2, but anyone using ash must know something about bits */
        if (arg2 >= 0)
        {
            if (arg1 < 0)
            {
                uint64_t z;
                z = (uint64_t)arg1;
                return((s7_int)(z << arg2));
            }
            return(arg1 << arg2);
        }
        return(arg1 >> -arg2);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1054c2
movq %rdx, %r14
movq %rsi, %rbx
xorl %eax, %eax
cmpb $0x0, 0x4d7d1(%rip)     # 0x152c60
movl $0x3f, %ecx
cmoveq %rax, %rcx
cmpq %rdx, %rcx
jg 0x10552e
movq %rbx, %rax
notq %rax
movq %r14, %rcx
xorq $0x3f, %rcx
orq %rax, %rcx
jne 0x1054c9
movl 0x4d56f(%rip), %ebx     # 0x152a28
shlq $0x3f, %rbx
jmp 0x105563
xorl %ebx, %ebx
jmp 0x105563
movq 0xbd8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x49485(%rip), %rcx     # 0x14e960
movq 0x1f00(%rdi), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rdi), %rdx
movq 0x1f00(%rdi), %rsi
movq 0x4d545(%rip), %r8      # 0x152a40
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x3b366
xorl %eax, %eax
cmpb $0x0, 0x4d729(%rip)     # 0x152c60
movq $-0x3f, %rcx
cmoveq %rax, %rcx
cmpq %r14, %rcx
jle 0x10554d
sarq $0x3f, %rbx
jmp 0x105563
testq %r14, %r14
js 0x10555a
movl %r14d, %ecx
shlq %cl, %rbx
jmp 0x105563
negb %r14b
movl %r14d, %ecx
sarq %cl, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: integer_length
static int32_t integer_length(s7_int a)
    {
#define I_8 256LL
#define I_16 65536LL
#define I_24 16777216LL
#define I_32 4294967296LL
#define I_40 1099511627776LL
#define I_48 281474976710656LL
#define I_56 72057594037927936LL

        /* a might be most-negative-fixnum! in Clisp: (integer-length -9223372036854775808) -> 63
        */
        if (a < 0)
        {
            if (a == s7_int_min) return(63);
            a = -a;
        }
        if (a < I_8) return(bits[a]);
        if (a < I_16) return(8 + bits[a >> 8]);
        if (a < I_24) return(16 + bits[a >> 16]);
        if (a < I_32) return(24 + bits[a >> 24]);
        if (a < I_40) return(32 + bits[a >> 32]);
        if (a < I_48) return(40 + bits[a >> 40]);
        if (a < I_56) return(48 + bits[a >> 48]);
        return(56 + bits[a >> 56]);
    }

// Assembly:
cmpq $0xff, %rdi
jg 0x105582
leaq 0xc952(%rip), %rax      # 0x111ed0
movl (%rax,%rdi,4), %eax
retq
cmpq $0xffff, %rdi           # imm = 0xFFFF
jg 0x10559d
shrq $0x8, %rdi
leaq 0xc93a(%rip), %rax      # 0x111ed0
movl (%rax,%rdi,4), %eax
addl $0x8, %eax
retq
cmpq $0xffffff, %rdi         # imm = 0xFFFFFF
jg 0x1055b8
shrq $0x10, %rdi
leaq 0xc91f(%rip), %rax      # 0x111ed0
movl (%rax,%rdi,4), %eax
addl $0x10, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rdi
jg 0x1055d4
shrq $0x18, %rdi
leaq 0xc903(%rip), %rax      # 0x111ed0
movl (%rax,%rdi,4), %eax
addl $0x18, %eax
retq
movabsq $0xffffffffff, %rax     # imm = 0xFFFFFFFFFF
cmpq %rax, %rdi
jg 0x1055f5
shrq $0x20, %rdi
leaq 0xc8e2(%rip), %rax      # 0x111ed0
movl (%rax,%rdi,4), %eax
addl $0x20, %eax
retq
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
cmpq %rax, %rdi
jg 0x105616
shrq $0x28, %rdi
leaq 0xc8c1(%rip), %rax      # 0x111ed0
movl (%rax,%rdi,4), %eax
addl $0x28, %eax
retq
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
cmpq %rax, %rdi
jg 0x105637
shrq $0x30, %rdi
leaq 0xc8a0(%rip), %rax      # 0x111ed0
movl (%rax,%rdi,4), %eax
addl $0x30, %eax
retq
shrq $0x38, %rdi
leaq 0xc88e(%rip), %rax      # 0x111ed0
movl (%rax,%rdi,4), %eax
addl $0x38, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: char_with_error_check
static s7_pointer char_with_error_check(s7_scheme *sc, s7_pointer x, s7_pointer args, s7_pointer caller)
    {
        s7_pointer y;
        for (y = cdr(x); is_pair(y); y = cdr(y)) /* before returning #f, check for bad trailing arguments */
            if (!is_character_via_method(sc, car(y)))
                return(wrong_type_argument(sc, caller, position_of(y, args), car(y), T_CHARACTER));
        return(sc->F);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdi, %rbx
movq 0x10(%rsi), %rbp
cmpb $0x1, (%rbp)
jne 0x105723
movq %rdx, %r15
movq 0x8(%rbp), %r12
cmpb $0x8, (%r12)
je 0x105715
testb $0x40, 0x3(%r12)
je 0x105739
cmpb $0x1, 0x24c(%rbx)
jne 0x105739
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9a55
movq 0x1020(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0x105739
movq %rax, %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r14
cmpq 0x98(%rbx), %rax
ja 0x1056dc
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 %r12, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xbd41
cmpq 0x120(%rbx), %rax
je 0x105739
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
je 0x10566c
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
cmpq %r15, %rbp
je 0x10574e
incl %eax
movq 0x10(%r15), %r15
cmpq %rbp, %r15
jne 0x105743
movq (%rsp), %rcx
movq 0x8(%rcx), %r14
movslq %eax, %r15
cmpl $0x7ff, %r15d           # imm = 0x7FF
ja 0x10576f
leaq 0x491e7(%rip), %rax     # 0x14e950
movq (%rax,%r15,8), %rdx
jmp 0x1057a8
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x105787
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %r15, 0x8(%rdx)
movq 0x8(%rbp), %rcx
movq 0x140(%rbx), %r8
movq 0x4d2e6(%rip), %r9      # 0x152aa0
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb31d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_char_cmp
static s7_pointer g_char_cmp(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!s7_is_character(y))
            return(method_or_bust(sc, y, sym, args, T_CHARACTER, 1));

        for (x = cdr(args); is_pair(x); x = cdr(x))
        {
            if (!s7_is_character(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_CHARACTER, position_of(x, args)));
            if (charcmp(character(y), character(car(x))) != val)
                return(char_with_error_check(sc, x, args, sym));
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rbp
cmpb $0x8, (%rbp)
jne 0x10584e
xorl %eax, %eax
movq %r15, %r12
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x105868
movq 0x8(%r12), %r13
cmpb $0x8, (%r13)
jne 0x10587e
movb 0x8(%rbp), %cl
movb 0x8(%r13), %sil
cmpb %sil, %cl
movl $0x0, %edi
sbbl %edi, %edi
orl $0x1, %edi
cmpb %sil, %cl
cmovel %eax, %edi
movq %r13, %rbp
cmpl %edx, %edi
je 0x1057f6
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x105649
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0x1058e1
movq 0x118(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x105896
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %rbp, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r15, %r12
je 0x1058d2
incl %r9d
movq 0x10(%r15), %r15
cmpq %r12, %r15
jne 0x1058c6
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movl $0x8, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_string_cmp
static s7_pointer g_string_cmp(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!is_string(y))
            return(method_or_bust(sc, y, sym, args, T_STRING, 1));

        for (x = cdr(args); is_not_null(x); x = cdr(x))
        {
            if (!is_string(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_STRING, position_of(x, args)));
            if (scheme_strcmp(y, car(x)) != val)
            {
                for (y = cdr(x); is_pair(y); y = cdr(y))
                    if (!is_string_via_method(sc, car(y)))
                        return(wrong_type_argument(sc, sym, position_of(y, args), car(y), T_STRING));
                return(sc->F);
            }
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %r13
cmpb $0x13, (%r13)
jne 0x105abb
movl %edx, %ebp
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x110(%rdi), %rbx
movq %r14, %r15
movq 0x10(%r15), %r15
cmpq %rbx, %r15
je 0x105ad2
movq 0x8(%r15), %r12
cmpb $0x13, (%r12)
jne 0x105ae3
movq %r13, %rdi
movq %r12, %rsi
callq 0x105c0a
movq %r12, %r13
cmpl %ebp, %eax
je 0x105a4b
movq 0x8(%rsp), %rbx
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x105b60
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x105ce3
testb %al, %al
jne 0x105a7a
movl $0x1, %eax
cmpq %r14, %r15
je 0x105b76
movq 0x10(%rsp), %rcx
incl %eax
movq 0x10(%r14), %r14
cmpq %r15, %r14
jne 0x105aab
jmp 0x105b7b
movq %r13, %rsi
movq %rcx, %rdx
movq %r14, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0x105b4d
movq 0x8(%rsp), %rax
movq 0x118(%rax), %rax
jmp 0x105b67
movq 0x8(%rsp), %rbx
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x105b00
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %r13, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r14, %r15
je 0x105b3c
incl %r9d
movq 0x10(%r14), %r14
cmpq %r15, %r14
jne 0x105b30
movq %rbx, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
movl $0x13, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae
movq 0x120(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %r14
movslq %eax, %rbx
cmpl $0x7ff, %ebx            # imm = 0x7FF
ja 0x105b9c
leaq 0x48dbf(%rip), %rax     # 0x14e950
movq (%rax,%rbx,8), %rdx
movq 0x8(%rsp), %r12
jmp 0x105bde
movq 0x8(%rsp), %r12
movq 0x90(%r12), %rax
cmpq 0x98(%r12), %rax
ja 0x105bbb
movq %r12, %rdi
callq 0xb389
movq 0x90(%r12), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r12)
movq -0x8(%rax), %rdx
movq $0xb, (%rdx)
movq %rbx, 0x8(%rdx)
movq 0x8(%r15), %rcx
movq 0x140(%r12), %r8
movq 0x4cf07(%rip), %r9      # 0x152af8
movq %r12, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb31d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: scheme_strcmp
static int32_t scheme_strcmp(s7_pointer s1, s7_pointer s2)
    {
        /* tricky here because str[i] must be treated as unsigned: (string<? (string (integer->char #xf0)) (string (integer->char #x70)))
         *   and null or lack thereof does not say anything about the string end
         */
        size_t i, len, len1, len2;
        char *str1, *str2;

        len1 = (size_t)string_length(s1);
        len2 = (size_t)string_length(s2);
        if (len1 > len2)
            len = len2;
        else len = len1;

        str1 = string_value(s1);
        str2 = string_value(s2);

        if (len < sizeof(size_t))
        {
            for (i = 0; i < len; i++)
            {
                if ((uint8_t)(str1[i]) < (uint8_t )(str2[i]))
                    return(-1);
                if ((uint8_t)(str1[i]) > (uint8_t)(str2[i]))
                    return(1);
            }
        }
        else
        {
            /* this algorithm from stackoverflow(?), with various changes (original did not work for large strings, etc) */
            size_t last, pos;
            size_t *ptr1, *ptr2;

            last = len / sizeof(size_t);
            for (ptr1 = (size_t *)str1, ptr2 = (size_t *)str2, i = 0; i < last; i++)
                if (ptr1[i] ^ ptr2[i])
                    break;

            for (pos = i * sizeof(size_t); pos < len; pos++)
            {
                if ((uint8_t)str1[pos] < (uint8_t)str2[pos])
                    return(-1);
                if ((uint8_t)str1[pos] > (uint8_t)str2[pos])
                    return(1);
            }
        }

        if (len1 < len2)
            return(-1);
        if (len1 > len2)
            return(1);
        return(0);
    }

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rsi
cmpq %rdx, %rcx
movq %rdx, %r8
cmovbq %rcx, %r8
cmpq $0x7, %r8
ja 0x105c54
testq %r8, %r8
je 0x105cbb
xorl %eax, %eax
movb (%rsi,%rax), %r9b
cmpb %r9b, (%rdi,%rax)
jb 0x105cce
ja 0x105cd5
incq %rax
cmpq %rax, %r8
jne 0x105c36
jmp 0x105cbb
movq %r8, %rax
shrq $0x3, %rax
xorl %r9d, %r9d
movq (%rdi,%r9,8), %r10
cmpq (%rsi,%r9,8), %r10
jne 0x105c73
incq %r9
cmpq %r9, %rax
jne 0x105c5e
movq %rax, %r9
shlq $0x3, %r9
cmpq %r8, %r9
setb %r10b
jae 0x105cb5
movb (%rdi,%r9), %r11b
movb (%rsi,%r9), %bl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb %bl, %r11b
jb 0x105cb5
incq %r9
cmpb %bl, %r11b
ja 0x105cdc
cmpq %r8, %r9
setb %r10b
je 0x105cb5
movb (%rdi,%r9), %r11b
movb (%rsi,%r9), %bl
incq %r9
cmpb %bl, %r11b
jae 0x105c95
jmp 0x105cb5
testb $0x1, %r10b
jne 0x105ccc
xorl %esi, %esi
cmpq %rdx, %rcx
seta %sil
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %esi, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x105ccc
movl $0x1, %eax
jmp 0x105ccc
movl $0x1, %eax
jmp 0x105cb5
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: is_string_via_method
static bool is_string_via_method(s7_scheme *sc, s7_pointer p)
    {
        if (s7_is_string(p))
            return(true);
        if (has_active_methods(sc, p))
        {
            s7_pointer f;
            f = find_method(sc, find_let(sc, p), sc->is_string_symbol);
            if (f != sc->undefined)
                return(is_true(sc, s7_apply_function(sc, f, cons(sc, p, sc->nil))));
        }
        return(false);
    }

// Assembly:
movb $0x1, %al
cmpb $0x13, (%rsi)
je 0x105dab
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
testb $0x40, 0x3(%rsi)
je 0x105da0
movq %rdi, %rbx
cmpb $0x1, 0x24c(%rdi)
jne 0x105da0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq 0x1190(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
movq %rax, %r15
movq 0x128(%rbx), %r12
cmpq %r12, %rax
je 0x105d9b
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x105d5f
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 %r14, 0x8(%rdx)
movq %r13, 0x10(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbd41
cmpq 0x120(%rbx), %rax
setne %al
jmp 0x105d9b
cmpq %r12, %r15
jne 0x105da2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_char_cmp_ci
static s7_pointer g_char_cmp_ci(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!s7_is_character(y))
            return(method_or_bust(sc, y, sym, args, T_CHARACTER, 1));

        for (x = cdr(args); is_pair(x); x = cdr(x))
        {
            if (!s7_is_character(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_CHARACTER, position_of(x, args)));
            if (charcmp(upper_character(y), upper_character(car(x))) != val)
                return(char_with_error_check(sc, x, args, sym));
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rbp
cmpb $0x8, (%rbp)
jne 0x10601e
xorl %eax, %eax
movq %r15, %r12
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
jne 0x106038
movq 0x8(%r12), %r13
cmpb $0x8, (%r13)
jne 0x10604e
movb 0x9(%rbp), %cl
movb 0x9(%r13), %sil
cmpb %sil, %cl
movl $0x0, %edi
sbbl %edi, %edi
orl $0x1, %edi
cmpb %sil, %cl
cmovel %eax, %edi
movq %r13, %rbp
cmpl %edx, %edi
je 0x105fc6
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x105649
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0x1060b1
movq 0x118(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x106066
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rcx
movq $0x200001, (%rcx)       # imm = 0x200001
movq %rbp, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movl $0x1, %r9d
cmpq %r15, %r12
je 0x1060a2
incl %r9d
movq 0x10(%r15), %r15
cmpq %r12, %r15
jne 0x106096
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movl $0x8, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae