LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: set_car_p_pp
static s7_pointer set_car_p_pp(s7_scheme *sc, s7_pointer p1, s7_pointer p2)
                {
                    if (!is_mutable_pair(p1))
                        simple_wrong_type_argument(sc, sc->set_car_symbol, p1, T_PAIR);
                    set_car(p1, p2);
                    return(p2);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x10000ff, %eax        # imm = 0x10000FF
andl (%rsi), %eax
cmpl $0x1, %eax
je 0x89b08
movq 0x14a8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8f68(%rip), %r8      # 0x152a68
movq %r14, %rdx
callq 0xfac8
movq %rbx, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: set_cdr_p_pp
static s7_pointer set_cdr_p_pp(s7_scheme *sc, s7_pointer p1, s7_pointer p2)
                {
                    if (!is_mutable_pair(p1))
                        simple_wrong_type_argument(sc, sc->set_cdr_symbol, p1, T_PAIR);
                    set_cdr(p1, p2);
                    return(p2);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x10000ff, %eax        # imm = 0x10000FF
andl (%rsi), %eax
cmpl $0x1, %eax
je 0x89b79
movq 0x14b0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8ef7(%rip), %r8      # 0x152a68
movq %r14, %rdx
callq 0xfac8
movq %rbx, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: caar_p_p
static s7_pointer caar_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(car(p))))
                        return(caar(p));
                    return(simple_wrong_type_argument(sc, sc->caar_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89b9e
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89b9e
movq 0x8(%rax), %rax
retq
movq 0xca8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8eb1(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: cadr_p_p
static s7_pointer cadr_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(cdr(p))))
                        return(cadr(p));
                    return(simple_wrong_type_argument(sc, sc->cadr_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89bd2
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89bd2
movq 0x8(%rax), %rax
retq
movq 0xce0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8e7d(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: cdar_p_p
static s7_pointer cdar_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(car(p))))
                        return(cdar(p));
                    return(simple_wrong_type_argument(sc, sc->cdar_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89c06
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89c06
movq 0x10(%rax), %rax
retq
movq 0xd60(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8e49(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: cddr_p_p
static s7_pointer cddr_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(cdr(p))))
                        return(cddr(p));
                    return(simple_wrong_type_argument(sc, sc->cddr_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89c3a
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89c3a
movq 0x10(%rax), %rax
retq
movq 0xd98(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8e15(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: caddr_p_p
static s7_pointer caddr_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(cdr(p))) &&
                            (is_pair(cddr(p))))
                        return(caddr(p));
                    return(simple_wrong_type_argument(sc, sc->caddr_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89c77
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89c77
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89c77
movq 0x8(%rax), %rax
retq
movq 0xcd8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8dd8(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: caddar_p_p
static s7_pointer caddar_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(car(p))) &&
                            (is_pair(cdar(p))) &&
                            (is_pair(cddar(p))))
                        return(caddar(p));
                    return(simple_wrong_type_argument(sc, sc->caddar_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89cbd
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89cbd
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89cbd
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89cbd
movq 0x8(%rax), %rax
retq
movq 0xcc8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8d92(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: caadr_p_p
static s7_pointer caadr_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(cdr(p))) &&
                            (is_pair(cadr(p))))
                        return(caadr(p));
                    return(simple_wrong_type_argument(sc, sc->caadr_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89cfa
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89cfa
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89cfa
movq 0x8(%rax), %rax
retq
movq 0xca0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8d55(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: caaddr_p_p
static s7_pointer caaddr_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(cdr(p))) &&
                            (is_pair(cddr(p))) &&
                            (is_pair(caddr(p))))
                        return(caaddr(p));
                    return(simple_wrong_type_argument(sc, sc->caaddr_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89d40
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89d40
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89d40
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89d40
movq 0x8(%rax), %rax
retq
movq 0xc98(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8d0f(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: cadar_p_p
static s7_pointer cadar_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(car(p))) &&
                            (is_pair(cdar(p))))
                        return(cadar(p));
                    return(simple_wrong_type_argument(sc, sc->cadar_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89d7d
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89d7d
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89d7d
movq 0x8(%rax), %rax
retq
movq 0xcc0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8cd2(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: cadadr_p_p
static s7_pointer cadadr_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(cdr(p))) &&
                            (is_pair(cadr(p))) &&
                            (is_pair(cdadr(p))))
                        return(cadadr(p));
                    return(simple_wrong_type_argument(sc, sc->cadadr_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89dc3
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89dc3
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89dc3
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89dc3
movq 0x8(%rax), %rax
retq
movq 0xcb8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8c8c(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: cdadr_p_p
static s7_pointer cdadr_p_p(s7_scheme *sc, s7_pointer p)
                {
                    if ((is_pair(p)) &&
                            (is_pair(cdr(p))) &&
                            (is_pair(cadr(p))))
                        return(cdadr(p));
                    return(simple_wrong_type_argument(sc, sc->cdadr_symbol, p, T_PAIR));
                }

// Assembly:
movq %rsi, %rdx
cmpb $0x1, (%rsi)
jne 0x89e00
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x89e00
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x89e00
movq 0x10(%rax), %rax
retq
movq 0xd58(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc8c4f(%rip), %r8      # 0x152a68
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: newline_p_p
static s7_pointer newline_p_p(s7_scheme *sc, s7_pointer port)
    {
        if (!is_output_port(port))
        {
            if (port == sc->F) return(newline_char);
            return(method_or_bust_with_type_one_arg(sc, port, sc->newline_symbol, list_1(sc, port), an_output_port_string));
        }
        s7_newline(sc, port);
        return(newline_char);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x22, (%rsi)
movq 0x120(%rdi), %rax
jne 0x8a075
cmpq %rbx, %rax
je 0x8a0e5
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq *0x8(%rax)
jmp 0x8a0e5
cmpq %rbx, %rax
je 0x8a0e5
movq 0x1360(%r14), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x8a0a0
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 %rbx, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xd01fc(%rip), %r8      # 0x15a2c8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x103001
movq 0xc896c(%rip), %rax     # 0x152a58
movq 0x50(%rax), %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: write_p_pp
static s7_pointer write_p_pp(s7_scheme *sc, s7_pointer x, s7_pointer port)
    {
        if (port == sc->F) return(x);
        if (!is_output_port(port))
            return(method_or_bust_with_type(sc, port, sc->write_symbol, list_2(sc, x, port), an_output_port_string, 2));
        if (port_is_closed(port))
            s7_wrong_type_arg_error(sc, "write", 2, port, "an open output port");
        return(object_out(sc, x, port, P_WRITE));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, 0x120(%rdi)
je 0x8a7a7
movq %rdx, %r14
movq %rdi, %r15
cmpb $0x22, (%rdx)
jne 0x8a6fa
movq 0x8(%r14), %rax
cmpb $0x1, 0x2(%rax)
jne 0x8a6b2
leaq 0x88a0d(%rip), %rsi     # 0x1130a8
leaq 0x997d3(%rip), %r8      # 0x123e75
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xe25f
movzbl (%rbx), %eax
leaq 0xcfc84(%rip), %rcx     # 0x15a340
cmpb $0x1, (%rax,%rcx)
jne 0x8a78b
cmpl $0x15, %eax
jne 0x8a6d5
testb $0x1, 0x7(%rbx)
jne 0x8a78b
cmpq %rbx, 0x150(%r15)
je 0x8a78b
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x9b866
jmp 0x8a7a7
movq 0x16b8(%r15), %r12
movq 0x90(%r15), %rax
movq 0x110(%r15), %r13
cmpq 0x98(%r15), %rax
ja 0x8a720
movq %r15, %rdi
callq 0xb389
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%r15), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%r15)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %rbx, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0xcfb5a(%rip), %r8      # 0x15a2c8
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3da
leaq 0xcfbee(%rip), %r9      # 0x15a380
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *(%r9,%rax,8)
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: write_char_p_p
static s7_pointer write_char_p_p(s7_scheme *sc, s7_pointer c)
    {
        if (!s7_is_character(c))
            return(method_or_bust(sc, c, sc->write_char_symbol, list_1(sc, c), T_CHARACTER, 1));
        if (sc->output_port == sc->F) return(c);
        port_write_character(sc->output_port)(sc, s7_character(c), sc->output_port);
        return(c);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x8, (%rsi)
jne 0x8a7f8
movq 0x188(%r14), %rdx
cmpq 0x120(%r14), %rdx
je 0x8a7e9
movq 0x8(%rdx), %rax
movq 0x48(%rax), %rax
movzbl 0x8(%rbx), %esi
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x16a8(%r14), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x8a81e
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 %rbx, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x8, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: write_char_p_pp
static s7_pointer write_char_p_pp(s7_scheme *sc, s7_pointer c, s7_pointer port)
    {
        if (!s7_is_character(c))
            return(method_or_bust(sc, c, sc->write_char_symbol, list_2(sc, c, port), T_CHARACTER, 1));
        if (port == sc->F) return(c);
        if (!is_output_port(port))
            return(method_or_bust_with_type(sc, port, sc->write_char_symbol, list_2(sc, c, port), an_output_port_string, 2));
        port_write_character(port)(sc, s7_character(c), port);
        return(c);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x8, (%rsi)
jne 0x8a8b4
cmpq %r15, 0x120(%r14)
je 0x8a8a7
cmpb $0x22, (%r15)
jne 0x8a944
movq 0x8(%r15), %rax
movq 0x48(%rax), %rax
movzbl 0x8(%rbx), %esi
movq %r14, %rdi
movq %r15, %rdx
callq *0x8(%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x16a8(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x8a8da
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%r14), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %rbx, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x8, %r8d
movl $0x1, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf1ae
movq 0x16a8(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x8a96a
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%r14), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%r14)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %rbx, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0xcf910(%rip), %r8      # 0x15a2c8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf3da
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: char_position_p_ppi
static s7_pointer char_position_p_ppi(s7_scheme *sc, s7_pointer p1, s7_pointer p2, s7_int start)
    {
        /* p1 is char, p2 is string */
        if (is_string(p2))
        {
            if (start >= 0)
            {
                const char *porig, *p;
                s7_int len;
                char c;
                c = character(p1);
                len = string_length(p2);
                porig = string_value(p2);
                if (start >= len) return(sc->F);
                p = strchr((const char *)(porig + start), (int)c);
                if (p) return(make_integer(sc, p - porig));
            }
            else wrong_type_argument_with_type(sc, sc->char_position_symbol, 3, s7_make_integer(sc, start), a_non_negative_integer_string);
        }
        else simple_wrong_type_argument(sc, sc->char_position_symbol, p2, T_STRING);
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x13, (%rdx)
jne 0x8ada3
testq %rcx, %rcx
js 0x8adc9
cmpq %rcx, 0x8(%rdx)
jle 0x8ae07
movq 0x10(%rdx), %r15
movsbl 0x8(%rsi), %esi
addq %r15, %rcx
movq %rcx, %rdi
callq 0x91d0
testq %rax, %rax
je 0x8ae10
movq %rax, %r14
subq %r15, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x8ae14
leaq 0xc3bb6(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x8ae4d
movq 0xde0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xc7d3c(%rip), %r8      # 0x152af8
movq %rbx, %rdi
callq 0xfac8
jmp 0x8ae53
movq 0xde0(%rbx), %rax
movq 0x8(%rax), %r14
movq 0xc3b8d(%rip), %r15     # 0x14e968
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xdff8
movq 0x140(%rbx), %r8
movq 0xcfde4(%rip), %r9      # 0x15abd8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xb31d
jmp 0x8ae53
movq 0x120(%rbx), %rax
jmp 0x8ae4d
movb $0x1, %cl
jmp 0x8ae4f
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x8ae2c
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
xorl %ecx, %ecx
testb %cl, %cl
je 0x8ae5a
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: append_p_pp
static s7_pointer append_p_pp(s7_scheme *sc, s7_pointer p1, s7_pointer p2)
                {
                    /* plist in use above */
                    s7_pointer val;
                    sc->temp7 = list_2(sc, p1, p2);
                    val = g_append(sc, sc->temp7);
                    sc->temp7 = sc->nil;
                    return(val);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0x110(%rdi), %r12
cmpq 0x98(%rdi), %rax
ja 0x8ae90
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rsi
movq %rcx, (%rsi)
movq %r14, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rsi, 0x528(%rbx)
movq %rbx, %rdi
callq 0x7e9d0
movq 0x110(%rbx), %rcx
movq %rcx, 0x528(%rbx)
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: append_p_ppp
static s7_pointer append_p_ppp(s7_scheme *sc, s7_pointer p1, s7_pointer p2, s7_pointer p3)
                {
                    s7_pointer val;
                    sc->temp7 = list_3(sc, p1, p2, p3);
                    val = g_append(sc, sc->temp7);
                    sc->temp7 = sc->nil;
                    return(val);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0x110(%rdi), %r13
cmpq 0x98(%rdi), %rax
ja 0x8af34
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rdx
movq %rcx, (%rdx)
movq %r15, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rax), %rsi
movq %rcx, (%rsi)
movq %r14, 0x8(%rsi)
movq %rdx, 0x10(%rsi)
movq %rsi, 0x528(%rbx)
movq %rbx, %rdi
callq 0x7e9d0
movq 0x110(%rbx), %rcx
movq %rcx, 0x528(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: round_i_7d
static s7_int round_i_7d(s7_scheme *sc, s7_double z)
    {
        if (is_NaN(z))
            simple_out_of_range(sc, sc->round_symbol, wrap_real(sc, z), its_nan_string);
        if ((is_inf(z)) ||
                (z > REAL_TO_INT_LIMIT) ||
                (z < -REAL_TO_INT_LIMIT))
            simple_out_of_range(sc, sc->round_symbol, wrap_real(sc, z), its_too_large_string);
        return((s7_int)r5rs_round(z));
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
ucomisd %xmm0, %xmm0
jp 0x8c31f
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
sete %al
movsd 0x82e4b(%rip), %xmm1    # 0x10f0e0
ucomisd %xmm0, %xmm1
ja 0x8c2a9
ucomisd 0x82e35(%rip), %xmm0    # 0x10f0d8
ja 0x8c2a9
testb %al, %al
je 0x8c30f
movq 0x1498(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xc676b(%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, 0x8(%rsp)
callq 0x3b366
movsd 0x8(%rsp), %xmm0
callq 0x103892
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
retq
movq 0x1498(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xd12f5(%rip), %rsi     # 0x15d640
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, 0x8(%rsp)
callq 0x3b366
movsd 0x8(%rsp), %xmm0
jmp 0x8c273
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: floor_i_7d
static s7_int floor_i_7d(s7_scheme *sc, s7_double x)
    {

        if (is_NaN(x))
            simple_out_of_range(sc, sc->floor_symbol, wrap_real(sc, x), its_nan_string);
        if (fabs(x) > REAL_TO_INT_LIMIT)
            simple_out_of_range(sc, sc->floor_symbol, wrap_real(sc, x), its_too_large_string);
        return((s7_int)floor(x));
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
ucomisd %xmm0, %xmm0
jp 0x8c426
movapd 0x86a2c(%rip), %xmm1    # 0x112dd0
andpd %xmm0, %xmm1
ucomisd 0x82d28(%rip), %xmm1    # 0x10f0d8
jbe 0x8c416
movq 0xf08(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xc6662(%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
movapd %xmm0, (%rsp)
callq 0x3b366
movapd (%rsp), %xmm0
callq 0x95f0
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
retq
movq 0xf08(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xd11ee(%rip), %rsi     # 0x15d640
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
movapd %xmm0, (%rsp)
callq 0x3b366
movapd (%rsp), %xmm0
jmp 0x8c39c
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: floor_i_7p
static s7_int floor_i_7p(s7_scheme *sc, s7_pointer p)
    {
        if (is_t_integer(p)) return(s7_integer(p));
        if (is_t_real(p)) return(floor_i_7d(sc, real(p)));
        if (is_t_ratio(p)) return((s7_int)(floor(fraction(p))));
        if (has_active_methods(sc, p))
            return(s7_integer(find_and_apply_method(sc, find_let(sc, p), sc->floor_symbol, list_1(sc, p))));
        s7_wrong_type_arg_error(sc, "floor", 0, p, "a real number");
        return(0);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rsi), %eax
cmpl $0xd, %eax
je 0x8c4f2
cmpl $0xc, %eax
je 0x8c4bd
cmpl $0xb, %eax
jne 0x8c50c
movq 0x8(%rbx), %r15
jmp 0x8c5ac
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rax, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rcx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x95f0
cvttsd2si %xmm0, %r15
jmp 0x8c5ac
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8c38a
testb $0x40, 0x3(%rbx)
je 0x8c58e
cmpb $0x1, 0x24c(%r14)
jne 0x8c58e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq %rax, %r15
movq 0xf08(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x8c550
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 %rbx, 0x8(%rcx)
movq %r13, 0x10(%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x967ca
cmpb $0xb, (%rax)
jne 0x8c5bd
movq 0x8(%rax), %r15
jmp 0x8c5ac
leaq 0x8b2e6(%rip), %rsi     # 0x11787b
leaq 0x881a5(%rip), %r8      # 0x114741
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xe25f
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x8c5ac
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: ceiling_i_7p
static s7_int ceiling_i_7p(s7_scheme *sc, s7_pointer p)
    {
        if (is_t_integer(p)) return(s7_integer(p));
        if (is_t_real(p)) return(ceiling_i_7d(sc, real(p)));
        if (is_t_ratio(p)) return((s7_int)(ceil(fraction(p))));
        if (has_active_methods(sc, p))
            return(s7_integer(find_and_apply_method(sc, find_let(sc, p), sc->ceiling_symbol, list_1(sc, p))));
        s7_wrong_type_arg_error(sc, "ceiling", 0, p, "a real number");
        return(0);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rsi), %eax
cmpl $0xd, %eax
je 0x8c625
cmpl $0xc, %eax
je 0x8c5f0
cmpl $0xb, %eax
jne 0x8c63f
movq 0x8(%rbx), %r15
jmp 0x8c6df
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rax, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rcx, 0x10(%rsp)
fildll 0x10(%rsp)
fdivrp %st, %st(1)
fstpl 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x96c0
cvttsd2si %xmm0, %r15
jmp 0x8c6df
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8c8fa
testb $0x40, 0x3(%rbx)
je 0x8c6c1
cmpb $0x1, 0x24c(%r14)
jne 0x8c6c1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq %rax, %r15
movq 0xda8(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x8c683
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 %rbx, 0x8(%rcx)
movq %r13, 0x10(%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x967ca
cmpb $0xb, (%rax)
jne 0x8c6f0
movq 0x8(%rax), %r15
jmp 0x8c6df
leaq 0x8b1f0(%rip), %rsi     # 0x1178b8
leaq 0x88072(%rip), %r8      # 0x114741
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xe25f
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x8c6df
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: truncate_i_7d
static s7_int truncate_i_7d(s7_scheme *sc, s7_double x)
    {
        if (is_NaN(x))
            simple_out_of_range(sc, sc->truncate_symbol, wrap_real(sc, x), its_nan_string);
        if (is_inf(x))
            simple_out_of_range(sc, sc->truncate_symbol, wrap_real(sc, x), its_infinite_string);
        if (x > 0.0)
        {
            if (x > s7_int_max)
                simple_out_of_range(sc, sc->truncate_symbol, wrap_real(sc, x), its_too_large_string);
            return((s7_int)floor(x));
        }
        if (x < s7_int_min)
            simple_out_of_range(sc, sc->truncate_symbol, wrap_real(sc, x), its_too_large_string);
        return((s7_int)ceil(x));
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
ucomisd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
jp 0x8c895
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0x8c786
movq 0x1620(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xd0ef6(%rip), %rsi     # 0x15d648
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
callq 0x3b366
movsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8c80e
cmpb $0x0, 0xc6471(%rip)     # 0x152c08
je 0x8c7a1
movsd 0x8287f(%rip), %xmm1    # 0x10f020
ucomisd %xmm1, %xmm0
jbe 0x8c807
movq 0x1620(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xc626d(%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
callq 0x3b366
movsd 0x8(%rsp), %xmm0
callq 0x95f0
jmp 0x8c88a
cmpb $0x0, 0xc6213(%rip)     # 0x152a28
je 0x8c81f
movsd 0x82809(%rip), %xmm1    # 0x10f028
ucomisd %xmm0, %xmm1
jbe 0x8c885
movq 0x1620(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xc61ef(%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
callq 0x3b366
movsd 0x8(%rsp), %xmm0
callq 0x96c0
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
retq
movq 0x1620(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xd0d7f(%rip), %rsi     # 0x15d640
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
callq 0x3b366
movsd 0x8(%rsp), %xmm0
jmp 0x8c70d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: ceiling_i_7d
static s7_int ceiling_i_7d(s7_scheme *sc, s7_double x)
    {
        if (is_NaN(x))
            simple_out_of_range(sc, sc->ceiling_symbol, wrap_real(sc, x), its_nan_string);
        if ((is_inf(x)) ||
                (x > REAL_TO_INT_LIMIT) ||
                (x < -REAL_TO_INT_LIMIT))
            simple_out_of_range(sc, sc->ceiling_symbol, wrap_real(sc, x), its_too_large_string);
        return((s7_int)ceil(x));
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
ucomisd %xmm0, %xmm0
jp 0x8c9b8
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
sete %al
movsd 0x827b2(%rip), %xmm1    # 0x10f0e0
ucomisd %xmm0, %xmm1
ja 0x8c942
ucomisd 0x8279c(%rip), %xmm0    # 0x10f0d8
ja 0x8c942
testb %al, %al
je 0x8c9a8
movq 0xda8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xc60d2(%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, 0x8(%rsp)
callq 0x3b366
movsd 0x8(%rsp), %xmm0
callq 0x96c0
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
retq
movq 0xda8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x1f18(%rbx), %rcx
movsd %xmm0, 0x8(%rcx)
movq 0x1ef8(%rbx), %rcx
movq 0x1f18(%rbx), %rdx
movq 0xd0c5c(%rip), %rsi     # 0x15d640
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, 0x8(%rsp)
callq 0x3b366
movsd 0x8(%rsp), %xmm0
jmp 0x8c90c
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: modulo_i_ii
static s7_int c_mod(s7_int x, s7_int y)
    {
        s7_int z;
        if (y == 0) return(x);     /* else arithmetic exception */
        if ((y == 1) || (y == -1)) /* else (modulo most-negative-fixnum -1) will segfault with arithmetic exception */
            return(0);
        z = x % y;
        if (((y < 0) && (z > 0)) ||
                ((y > 0) && (z < 0)))
            return(z + y);
        return(z);
    }

// Assembly:
cmpq $-0x1, %rsi
je 0x8cc1c
movq %rdi, %rax
testq %rsi, %rsi
je 0x8cc1e
cmpq $0x1, %rsi
jne 0x8cc1f
xorl %eax, %eax
retq
cqto
idivq %rsi
testq %rsi, %rsi
sets %cl
movq %rdx, %rax
testq %rdx, %rdx
setg %dl
testb %dl, %cl
jne 0x8cc47
testq %rsi, %rsi
setle %cl
testq %rax, %rax
setns %dl
orb %cl, %dl
jne 0x8cc1e
addq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: float_vector_p_d
static s7_pointer float_vector_p_d(s7_scheme *sc, s7_double x)
                {
                    s7_pointer vec;
                    vec = make_simple_float_vector(sc, 1);
                    float_vector(vec, 0) = x;
                    return(vec);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x8cc75
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq $0x200017, (%rbx)       # imm = 0x200017
movq $0x1, 0x8(%rbx)
movq 0x850(%r14), %r15
testq %r15, %r15
je 0x8ccb6
movq 0x18(%r15), %rax
movq %rax, 0x850(%r14)
jmp 0x8cd6a
cmpq $0x0, 0x838(%r14)
jne 0x8ccfc
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r14)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x8ccda
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r14), %r15
movq 0x18(%r15), %rax
movq %rax, 0x838(%r14)
movl $0x0, 0x8(%r15)
movq 0x8c8(%r14), %rax
addq $0x8, %rax
cmpq $0x10001, %rax          # imm = 0x10001
jb 0x8cd4a
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, 0x8d0(%r14)
movq $0x0, 0x8c8(%r14)
movl $0x8, %eax
movq 0x8d0(%r14), %rcx
addq 0x8c8(%r14), %rcx
movq %rax, 0x8c8(%r14)
movq %rcx, (%r15)
movl $0x3, 0x8(%r15)
movq $0x8, 0x10(%r15)
movq %r15, 0x18(%rbx)
movq (%r15), %rax
movq %rax, 0x10(%rbx)
movq $0x0, 0x20(%r15)
leaq -0x4f7ac(%rip), %rax    # 0x3d5e0
movq %rax, 0x20(%rbx)
leaq -0x4f75a(%rip), %rax    # 0x3d63d
movq %rax, 0x28(%rbx)
movq 0x740(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x8cdc3
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 0x10(%rbx), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: int_vector_p_i
static s7_pointer int_vector_p_i(s7_scheme *sc, s7_int x)
                {
                    s7_pointer vec;
                    vec = make_simple_int_vector(sc, 1);
                    int_vector(vec, 0) = x;
                    return(vec);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x8ce17
movq %r15, %rdi
callq 0xb389
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %r14
movq $0x200016, (%r14)       # imm = 0x200016
movq $0x1, 0x8(%r14)
movq 0x850(%r15), %r12
testq %r12, %r12
je 0x8ce59
movq 0x18(%r12), %rax
movq %rax, 0x850(%r15)
jmp 0x8cf11
cmpq $0x0, 0x838(%r15)
jne 0x8ce9f
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r15)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0x8ce7d
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r15), %r12
movq 0x18(%r12), %rax
movq %rax, 0x838(%r15)
movl $0x0, 0x8(%r12)
movq 0x8c8(%r15), %rax
addq $0x8, %rax
cmpq $0x10001, %rax          # imm = 0x10001
jb 0x8ceef
movl $0x10000, %edi          # imm = 0x10000
callq 0x9480
movq %rax, 0x8d0(%r15)
movq $0x0, 0x8c8(%r15)
movl $0x8, %eax
movq 0x8d0(%r15), %rcx
addq 0x8c8(%r15), %rcx
movq %rax, 0x8c8(%r15)
movq %rcx, (%r12)
movl $0x3, 0x8(%r12)
movq $0x8, 0x10(%r12)
movq %r12, 0x18(%r14)
movq (%r12), %rax
movq %rax, 0x10(%r14)
movq $0x0, 0x20(%r12)
leaq 0x131cb(%rip), %rax     # 0xa0101
movq %rax, 0x20(%r14)
leaq 0x13226(%rip), %rax     # 0xa0167
movq %rax, 0x28(%r14)
movq 0x740(%r15), %r15
movq 0x8(%r15), %rsi
cmpq %rsi, 0x10(%r15)
jne 0x8cf6d
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r15)
movq (%r15), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r15)
movq (%r15), %rax
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
movq %r14, (%rax,%rcx,8)
movq 0x10(%r14), %rax
movq %rbx, (%rax)
movq %r14, %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: vector_append_p_pp
static s7_pointer vector_append_p_pp(s7_scheme *sc, s7_pointer p1, s7_pointer p2)
                {
                    s7_pointer val;
                    sc->temp7 = list_2(sc, p1, p2);
                    val = g_vector_append(sc, sc->temp7);
                    sc->temp7 = sc->nil;
                    return(val);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0x110(%rdi), %r12
cmpq 0x98(%rdi), %rax
ja 0x8dd89
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rsi
movq %rcx, (%rsi)
movq %r14, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rsi, 0x528(%rbx)
movq %rbx, %rdi
callq 0x7f619
movq 0x110(%rbx), %rcx
movq %rcx, 0x528(%rbx)
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: vector_to_list_p_p
static s7_pointer vector_to_list_p_p(s7_scheme *sc, s7_pointer p)
                {
                    s7_pointer val;
                    sc->temp7 = list_1(sc, p);
                    val = g_vector_to_list(sc, sc->temp7);
                    sc->temp7 = sc->nil;
                    return(val);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0x110(%rdi), %r15
cmpq 0x98(%rdi), %rax
ja 0x8e00f
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rsi
movq $0x200001, (%rsi)       # imm = 0x200001
movq %r14, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movq %rsi, 0x528(%rbx)
movq %rbx, %rdi
callq 0x7fad1
movq 0x110(%rbx), %rcx
movq %rcx, 0x528(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: denominator_i_7p
static s7_int denominator_i_7p(s7_scheme *sc, s7_pointer p)
    {
        if (!is_rational(p))
            return(integer(method_or_bust_with_type_one_arg(sc, p, sc->denominator_symbol, list_1(sc, p), a_rational_string)));
        if (is_t_integer(p))
            return(1);
        return(denominator(p));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl (%rsi), %ecx
leaq 0xc4869(%rip), %rax     # 0x1529f0
cmpb $0x0, (%rcx,%rax)
je 0x8e19d
movl $0x1, %eax
cmpb $0xb, %cl
je 0x8e20a
addq $0x10, %rbx
jmp 0x8e207
movq %rdi, %r14
movq 0xe70(%rdi), %r15
movq 0x90(%rdi), %rax
movq 0x110(%rdi), %r12
cmpq 0x98(%rdi), %rax
ja 0x8e1c6
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 %rbx, 0x8(%rcx)
movq %r12, 0x10(%rcx)
movq 0xcf406(%rip), %r8      # 0x15d5f8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x103001
movq %rax, %rbx
addq $0x8, %rbx
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: tree_leaves_i_7p
static s7_int tree_leaves_i_7p(s7_scheme *sc, s7_pointer p)
    {
        if ((sc->safety > NO_SAFETY) &&
                (tree_is_cyclic(sc, p)))
            s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-leaves: tree is cyclic", 27));
        return(tree_len(sc, p));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x6a0(%rdi)
jle 0x8e391
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b2ff
testb %al, %al
je 0x8e391
movq 0x1940(%r14), %rsi
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rdx
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r14)
leaq 0x96bcb(%rip), %rax     # 0x124f48
movq %rax, 0x10(%rdx)
movq $0x1b, 0x8(%rdx)
movq %r14, %rdi
callq 0x3b366
cmpq %rbx, 0x110(%r14)
je 0x8e3c3
movl $0x1, %eax
cmpb $0x1, (%rbx)
jne 0x8e3c5
movq 0x8(%rbx), %rcx
cmpq 0x17b0(%r14), %rcx
je 0x8e3c5
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa25cc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: is_port_closed_b_7p
static bool is_port_closed_b_7p(s7_scheme *sc, s7_pointer x)
    {
        if ((is_input_port(x)) || (is_output_port(x)))
            return(port_is_closed(x));
        if ((x == sc->output_port) && (x == sc->F))
            return(false);
        simple_wrong_type_argument_with_type(sc, sc->is_port_closed_symbol, x, wrap_string(sc, "a port", 6));
        return(false);
    }

// Assembly:
movq %rsi, %rdx
movb (%rsi), %al
andb $-0x2, %al
cmpb $0x22, %al
jne 0x8e4f0
movq 0x8(%rdx), %rax
movb 0x2(%rax), %al
retq
cmpq %rdx, 0x188(%rdi)
jne 0x8e502
cmpq %rdx, 0x120(%rdi)
je 0x8e553
pushq %rax
movq 0x1148(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r9
movq (%rax,%r9,8), %r8
leal 0x1(%r9), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x9600c(%rip), %rax     # 0x124547
movq %rax, 0x10(%r8)
movq $0x6, 0x8(%r8)
callq 0xfac8
xorl %eax, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: is_char_whitespace_b_7p
static bool is_char_whitespace_b_7p(s7_scheme *sc, s7_pointer c)
    {
        if (s7_is_character(c))
            return(is_char_whitespace(c));
        if (has_active_methods(sc, c))
        {
            s7_pointer f;
            f = find_method(sc, find_let(sc, c), sc->is_char_whitespace_symbol);
            if (f != sc->undefined)
                return(is_true(sc, s7_apply_function(sc, f, cons(sc, c, sc->nil))));
        }
        simple_wrong_type_argument(sc, sc->is_char_whitespace_symbol, c, T_CHARACTER);
        return(false);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpb $0x8, (%rsi)
jne 0x8e667
movb 0x12(%rbx), %al
jmp 0x8e734
movq %rdi, %r14
testb $0x40, 0x3(%rbx)
je 0x8e70e
cmpb $0x1, 0x24c(%r14)
jne 0x8e70e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9a55
movq 0x1030(%r14), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x99ef
movq %rax, %r15
movq 0x128(%r14), %r12
cmpq %r12, %rax
je 0x8e709
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x8e6cd
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rdx
movq $0x200001, (%rdx)       # imm = 0x200001
movq %rbx, 0x8(%rdx)
movq %r13, 0x10(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0xbd41
cmpq 0x120(%r14), %rax
setne %al
jmp 0x8e709
cmpq %r12, %r15
jne 0x8e734
movq 0x1030(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xc4379(%rip), %r8      # 0x152aa0
movq %r14, %rdi
movq %rbx, %rdx
callq 0xfac8
xorl %eax, %eax
andb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: iterator_is_at_end_b_7p
static bool iterator_is_at_end_b_7p(s7_scheme *sc, s7_pointer obj)
    {
        if (iter_ok(obj))
            return(false);
        if (!is_iterator(obj))
            simple_wrong_type_argument(sc, sc->iterator_is_at_end_symbol, obj, T_ITERATOR);
        return(true);
    }

// Assembly:
pushq %rbx
movq (%rsi), %rbx
testl %ebx, %ebx
js 0x8e782
movq %rsi, %rdx
cmpb $0x1d, (%rsi)
je 0x8e782
movq 0x11d0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc43cb(%rip), %r8      # 0x152b48
callq 0xfac8
testl %ebx, %ebx
setns %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: is_zero_b_7p
static bool is_zero_b_7p(s7_scheme *sc, s7_pointer p)
    {
#if WITH_GMP
        return(s7_is_zero(p));
#else
        if (is_t_integer(p))
            return(integer(p) == 0);
        if (is_t_real(p))
            return(real(p) == 0.0);
        if (!is_number(p))
            simple_wrong_type_argument_with_type(sc, sc->is_zero_symbol, p, a_number_string);
        return(false);
#endif
    }

// Assembly:
movq %rsi, %rdx
movzbl (%rsi), %eax
cmpl $0xd, %eax
je 0x8e7a2
cmpl $0xb, %eax
jne 0x8e7b5
cmpq $0x0, 0x8(%rdx)
sete %al
retq
xorpd %xmm0, %xmm0
cmpeqsd 0x8(%rdx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
leaq 0xc41b4(%rip), %rcx     # 0x152970
cmpb $0x0, (%rax,%rcx)
je 0x8e7c5
xorl %eax, %eax
retq
pushq %rax
movq 0x11c0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xcebc1(%rip), %r8      # 0x15d3a0
callq 0xfac8
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: is_negative_b_7p
static bool is_negative_b_7p(s7_scheme *sc, s7_pointer p)
    {
#if WITH_GMP
        return(s7_is_negative(p));
#else
        if (is_t_integer(p))
            return(integer(p) < 0);
        if (is_t_real(p))
            return(real(p) < 0.0);
        if (!is_real(p))
            simple_wrong_type_argument(sc, sc->is_negative_symbol, p, T_REAL);
        return(numerator(p) < 0);
#endif
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movzbl (%rsi), %eax
cmpl $0xd, %eax
je 0x8e834
cmpl $0xb, %eax
je 0x8e82a
leaq 0xc41ad(%rip), %rcx     # 0x1529b0
cmpb $0x0, (%rax,%rcx)
jne 0x8e82a
movq 0x1110(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc42a6(%rip), %r8      # 0x152ac8
movq %rbx, %rdx
callq 0xfac8
movq 0x8(%rbx), %rax
shrq $0x3f, %rax
jmp 0x8e840
xorpd %xmm0, %xmm0
ucomisd 0x8(%rbx), %xmm0
seta %al
popq %rbx
retq