LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: list_ref_p_pi_direct
static s7_pointer list_ref_p_pi_direct(s7_scheme *sc, s7_pointer p1, s7_int i1)
                {
                    s7_pointer p;
                    s7_int i;
                    if ((i1 < 0) || (i1 > sc->max_list_length))
                        out_of_range(sc, sc->list_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    for (i = 0, p = p1; ((is_pair(p)) && (i < i1)); i++, p = cdr(p));
                    if (!is_pair(p))
                    {
                        if (type(p) == T_NIL)
                            out_of_range(sc, sc->list_ref_symbol, small_int(2), wrap_integer1(sc, i1), its_too_large_string);
                        else simple_wrong_type_argument_with_type(sc, sc->list_ref_symbol, p1, a_proper_list_string);
                    }
                    return(car(p));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x825e7
cmpq %r15, 0x2b0(%rbx)
jge 0x82660
testq %r15, %r15
movq 0x1258(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc4364(%rip), %rcx     # 0x146960
movq 0x1f00(%rbx), %rdx
movq %r15, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
leaq 0xc8433(%rip), %rsi     # 0x14aa48
leaq 0xc8424(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
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 %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
movb (%r14), %al
cmpb $0x1, %al
sete %cl
setne %dl
testq %r15, %r15
setle %sil
orb %dl, %sil
movq %r14, %r12
jne 0x8269e
movl $0x1, %edx
movq %r14, %r12
movq 0x10(%r12), %r12
movb (%r12), %al
cmpb $0x1, %al
sete %cl
jne 0x8269e
leaq 0x1(%rdx), %rsi
cmpq %r15, %rdx
movq %rsi, %rdx
jl 0x82682
testb %cl, %cl
jne 0x8272d
movq 0x1258(%rbx), %rcx
movq 0x8(%rcx), %rsi
cmpb $0x2, %al
jne 0x82714
movq 0xc42a4(%rip), %rax     # 0x146960
movq 0x1f00(%rbx), %rcx
movq %r15, 0x8(%rcx)
movq 0x1ee8(%rbx), %rcx
movq 0x1f00(%rbx), %rdx
movq 0xc8364(%rip), %rdi     # 0x14aa40
movq 0x10(%rcx), %rcx
movq %rsi, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
jmp 0x8272d
movq 0x140(%rbx), %rcx
movq 0xd04f6(%rip), %r8      # 0x152c18
movq %rbx, %rdi
movq %r14, %rdx
callq 0xed2a
movq 0x8(%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: list_set_p_pip_direct
static s7_pointer list_set_p_pip_direct(s7_scheme *sc, s7_pointer p1, s7_int i1, s7_pointer p2)
                {
                    s7_pointer p;
                    s7_int i;
                    if ((i1 < 0) || (i1 > sc->max_list_length))
                        out_of_range(sc, sc->list_set_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    for (i = 0, p = p1; ((is_pair(p)) && (i < i1)); i++, p = cdr(p));
                    if (!is_pair(p))
                    {
                        if (type(p) == T_NIL)
                            out_of_range(sc, sc->list_set_symbol, small_int(2), wrap_integer1(sc, i1), its_too_large_string);
                        else simple_wrong_type_argument_with_type(sc, sc->list_set_symbol, p1, a_proper_list_string);
                    }
                    set_car(p, p2);
                    return(p2);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
js 0x82761
cmpq %r12, 0x2b0(%r14)
jge 0x827da
testq %r12, %r12
movq 0x1260(%r14), %rax
movq 0x8(%rax), %rax
movq 0xc41ea(%rip), %rcx     # 0x146960
movq 0x1f00(%r14), %rdx
movq %r12, 0x8(%rdx)
movq 0x1ee8(%r14), %rdx
leaq 0xc82b9(%rip), %rsi     # 0x14aa48
leaq 0xc82aa(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%r14), %rsi
movq (%rdi), %rdi
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 %rdi, 0x8(%rax)
movq 0x1948(%r14), %rsi
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
callq 0x38dfa
movb (%r15), %al
cmpb $0x1, %al
sete %cl
setne %dl
testq %r12, %r12
setle %sil
orb %dl, %sil
movq %r15, %r13
jne 0x82817
movl $0x1, %edx
movq %r15, %r13
movq 0x10(%r13), %r13
movb (%r13), %al
cmpb $0x1, %al
sete %cl
jne 0x82817
leaq 0x1(%rdx), %rsi
cmpq %r12, %rdx
movq %rsi, %rdx
jl 0x827fc
testb %cl, %cl
jne 0x828a6
movq 0x1260(%r14), %rcx
movq 0x8(%rcx), %rsi
cmpb $0x2, %al
jne 0x8288d
movq 0xc412b(%rip), %rax     # 0x146960
movq 0x1f00(%r14), %rcx
movq %r12, 0x8(%rcx)
movq 0x1ee8(%r14), %rcx
movq 0x1f00(%r14), %rdx
movq 0xc81eb(%rip), %rdi     # 0x14aa40
movq 0x10(%rcx), %rcx
movq %rsi, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%r14), %rsi
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
callq 0x38dfa
jmp 0x828a6
movq 0x140(%r14), %rcx
movq 0xd037d(%rip), %r8      # 0x152c18
movq %r14, %rdi
movq %r15, %rdx
callq 0xed2a
movq %rbx, 0x8(%r13)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_ref_p_pi
static s7_pointer string_ref_p_pi(s7_scheme *sc, s7_pointer p1, s7_int i1)
    {
        if (!is_string(p1))
            simple_wrong_type_argument(sc, sc->string_ref_symbol, p1, T_STRING);
        if ((i1 >= 0) && (i1 < string_length(p1)))
            return(chars[((uint8_t *)string_value(p1))[i1]]);
        out_of_range(sc, sc->string_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
        return(p1);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x13, (%rsi)
je 0x828ee
movq 0x1548(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xc8215(%rip), %r8      # 0x14aaf8
movq %r14, %rdi
movq %rbx, %rdx
callq 0xed2a
testq %r15, %r15
js 0x8290f
cmpq %r15, 0x8(%rbx)
jle 0x8290f
movq 0xc8158(%rip), %rax     # 0x14aa58
movq 0x10(%rbx), %rcx
movzbl (%rcx,%r15), %ecx
movq (%rax,%rcx,8), %rbx
jmp 0x82988
movq 0x1548(%r14), %rax
movq 0x8(%rax), %rax
movq 0xc403f(%rip), %rcx     # 0x146960
movq 0x1f00(%r14), %rdx
movq %r15, 0x8(%rdx)
movq 0x1ee8(%r14), %rdx
testq %r15, %r15
leaq 0xc810b(%rip), %rsi     # 0x14aa48
leaq 0xc80fc(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%r14), %rsi
movq (%rdi), %rdi
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 %rdi, 0x8(%rax)
movq 0x1948(%r14), %rsi
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_set_p_pip
static s7_pointer string_set_p_pip(s7_scheme *sc, s7_pointer p1, s7_int i1, s7_pointer p2)
    {
        if (!is_string(p1))
            simple_wrong_type_argument(sc, sc->string_set_symbol, p1, T_STRING);
        if (!s7_is_character(p2))
            simple_wrong_type_argument(sc, sc->string_set_symbol, p2, T_CHARACTER);
        if ((i1 >= 0) && (i1 < string_length(p1)))
            string_value(p1)[i1] = s7_character(p2);
        else out_of_range(sc, sc->string_set_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
        return(p2);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpb $0x13, (%rsi)
je 0x82a0f
movq 0x1550(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xc80f4(%rip), %r8      # 0x14aaf8
movq %r14, %rdi
movq %r12, %rdx
callq 0xed2a
cmpb $0x8, (%rbx)
je 0x82a38
movq 0x1550(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xc8073(%rip), %r8      # 0x14aaa0
movq %r14, %rdi
movq %rbx, %rdx
callq 0xed2a
testq %r15, %r15
js 0x82a52
cmpq %r15, 0x8(%r12)
jle 0x82a52
movb 0x8(%rbx), %al
movq 0x10(%r12), %rcx
movb %al, (%rcx,%r15)
jmp 0x82acb
movq 0x1550(%r14), %rax
movq 0x8(%rax), %rax
movq 0xc3efc(%rip), %rcx     # 0x146960
movq 0x1f00(%r14), %rdx
movq %r15, 0x8(%rdx)
movq 0x1ee8(%r14), %rdx
testq %r15, %r15
leaq 0xc7fc8(%rip), %rsi     # 0x14aa48
leaq 0xc7fb9(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%r14), %rsi
movq (%rdi), %rdi
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 %rdi, 0x8(%rax)
movq 0x1948(%r14), %rsi
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
callq 0x38dfa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_ref_p_pi_direct
static s7_pointer string_ref_p_pi_direct(s7_scheme *sc, s7_pointer p1, s7_int i1)
    {
        if ((i1 >= 0) && (i1 < string_length(p1)))
            return(chars[((uint8_t *)string_value(p1))[i1]]);
        out_of_range(sc, sc->string_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
        return(p1);
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
js 0x82afe
cmpq %rdx, 0x8(%rbx)
jle 0x82afe
movq 0xc7f68(%rip), %rax     # 0x14aa58
movq 0x10(%rbx), %rcx
movzbl (%rcx,%rdx), %ecx
movq (%rax,%rcx,8), %rbx
jmp 0x82b74
movq 0x1548(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc3e50(%rip), %rcx     # 0x146960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rsi
testq %rdx, %rdx
leaq 0xc7f1c(%rip), %rdx     # 0x14aa48
leaq 0xc7f0d(%rip), %r8      # 0x14aa40
cmovsq %rdx, %r8
movq 0x1f00(%rdi), %rdx
movq (%r8), %r8
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_set_p_pip_direct
static s7_pointer string_set_p_pip_direct(s7_scheme *sc, s7_pointer p1, s7_int i1, s7_pointer p2)
    {
        if ((i1 >= 0) && (i1 < string_length(p1)))
            string_value(p1)[i1] = s7_character(p2);
        else out_of_range(sc, sc->string_set_symbol, small_int(2),make_integer(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
        return(p2);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
testq %rdx, %rdx
js 0x82ba6
cmpq %r15, 0x8(%rsi)
jle 0x82bba
movb 0x8(%rbx), %al
movq 0x10(%rsi), %rcx
movb %al, (%rcx,%r15)
jmp 0x82c70
movq 0x1550(%r14), %rax
movq 0x8(%rax), %r13
movq 0xc3da8(%rip), %r12     # 0x146960
jmp 0x82be2
movq 0x1550(%r14), %rax
movq 0x8(%rax), %r13
movq 0xc3d94(%rip), %r12     # 0x146960
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0x82be2
leaq 0xc3d74(%rip), %rax     # 0x146950
movq (%rax,%r15,8), %rax
jmp 0x82c1b
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x82c01
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
testq %r15, %r15
leaq 0xc7e23(%rip), %rcx     # 0x14aa48
leaq 0xc7e14(%rip), %rdx     # 0x14aa40
cmovsq %rcx, %rdx
movq (%rdx), %rcx
movq 0x1ee8(%r14), %rdx
movq 0x10(%rdx), %rdx
movq %r13, 0x8(%rdx)
movq 0x10(%rdx), %rdx
movq %r12, 0x8(%rdx)
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%r14), %rsi
movq 0x1ee8(%r14), %rdx
movq %r14, %rdi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: random_p_p
static s7_pointer random_p_p(s7_scheme *sc, s7_pointer num)
    {
        s7_pointer r;
        r = sc->default_rng;
        if (is_t_integer(num))
            return(make_integer(sc, (s7_int)(integer(num) * next_random(r))));
        if (is_t_real(num))
            return(make_real(sc, real(num) * next_random(r)));
        return(g_random(sc, set_plist_1(sc, num)));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xaa0(%rdi), %rax
movzbl (%rsi), %ecx
cmpl $0xd, %ecx
je 0x82fa7
cmpl $0xb, %ecx
jne 0x83019
cvtsi2sdq 0x8(%rsi), %xmm0
imulq $0x7f13ac69, 0x8(%rax), %rcx # imm = 0x7F13AC69
addq 0x10(%rax), %rcx
movl %ecx, %edx
movq %rdx, 0x8(%rax)
shrq $0x20, %rcx
movq %rcx, 0x10(%rax)
cvtsi2sd %rdx, %xmm1
divsd 0x830c7(%rip), %xmm1    # 0x106048
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x8303a
leaq 0xc39b2(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x83073
imulq $0x7f13ac69, 0x8(%rax), %rcx # imm = 0x7F13AC69
addq 0x10(%rax), %rcx
movl %ecx, %edx
cvtsi2sd %rdx, %xmm0
divsd 0x83086(%rip), %xmm0    # 0x106048
mulsd 0x8(%rsi), %xmm0
movq %rdx, 0x8(%rax)
shrq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x82ffc
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xa550
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0x83073
movq 0x700(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6ee9b
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x83059
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: number_to_string_p_i
static s7_pointer number_to_string_p_i(s7_scheme *sc, s7_int p)
    {
        s7_int nlen = 0;
        char *res;
        res = integer_to_string(sc, p, &nlen);
        return(make_string_with_length(sc, res, nlen));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc799c(%rip), %eax     # 0x14aa28
shlq $0x3f, %rax
cmpq %rsi, %rax
jne 0x830a7
leaq 0x935dc(%rip), %r15     # 0x116678
movl $0x14, %r14d
jmp 0x8312d
leaq 0xb0f(%rbx), %r15
leaq 0xb0e(%rbx), %rdi
movb $0x0, 0xb0f(%rbx)
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
movq $-0x1, %r8
xorl %r14d, %r14d
leaq 0x93469(%rip), %r9      # 0x116540
movabsq $-0x3333333333333333, %r10 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %r10
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r11
subq %rax, %r11
movb (%r9,%r11), %al
movb %al, 0x1(%rdi,%r8)
incq %r14
decq %r8
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x830e1
testq %rsi, %rsi
js 0x8311b
subq %r14, %r15
jmp 0x8312d
movb $0x2d, 0x1(%rdi,%r8)
subq %r14, %rdi
negq %r8
movq %r8, %r14
movq %rdi, %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x8314c
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r12
movq $0x200013, (%r12)       # imm = 0x200013
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x9357
movq %rax, 0x20(%r12)
movq (%rax), %rdi
movq %rdi, 0x10(%r12)
testq %r14, %r14
jle 0x83191
movq %r15, %rsi
movq %r14, %rdx
callq 0x83e0
movq 0x10(%r12), %rdi
movb $0x0, (%rdi,%r14)
movq %r14, 0x8(%r12)
movq $0x0, 0x18(%r12)
movq 0x738(%rbx), %rbx
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
cmpq 0x8(%rbx), %rsi
jne 0x831d3
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%rbx)
movq 0x10(%rbx), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%rbx)
movq %r12, (%rax,%rsi,8)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: number_to_string_p_p
static s7_pointer number_to_string_p_p(s7_scheme *sc, s7_pointer p)
    {
        s7_int nlen = 0;
        char *res;
        if (!is_number(p))
            return(wrong_type_argument_with_type(sc, sc->number_to_string_symbol, 1, p, a_number_string));
        res = number_to_string_base_10(sc, p, 0, sc->float_format_precision, 'g', &nlen, P_WRITE);
        return(make_string_with_length(sc, res, nlen));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq $0x0, (%rsp)
movzbl (%rsi), %ecx
leaq 0xc7762(%rip), %rdx     # 0x14a970
cmpb $0x0, (%rcx,%rdx)
je 0x832f9
movslq 0x468(%rbx), %rcx
movq %rsp, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
movl $0x67, %r8d
movq %r14, %r9
callq 0x8f49e
movq %rax, %r12
movq (%r14), %r15
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x8325d
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200013, (%r14)       # imm = 0x200013
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0x9357
movq %rax, 0x20(%r14)
movq (%rax), %rdi
movq %rdi, 0x10(%r14)
testq %r15, %r15
jle 0x8329e
movq %r12, %rsi
movq %r15, %rdx
callq 0x83e0
movq 0x10(%r14), %rdi
movb $0x0, (%rdi,%r15)
movq %r15, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq 0x738(%rbx), %rbx
movq (%rbx), %rax
movq 0x10(%rbx), %rsi
cmpq 0x8(%rbx), %rsi
jne 0x832de
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x8510
movq %rax, (%rbx)
movq 0x10(%rbx), %rsi
leaq 0x1(%rsi), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, (%rax,%rsi,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1370(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0xc364d(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %r8
movq 0xd2087(%rip), %r9      # 0x1553a0
movq %rbx, %rdi
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa4e4
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: number_to_string_p_pp
static s7_pointer number_to_string_p_pp(s7_scheme *sc, s7_pointer p1, s7_pointer p2)
    {
        s7_int nlen = 0, radix;
        block_t *b;

        if (!is_number(p1))
            return(wrong_type_argument_with_type(sc, sc->number_to_string_symbol, 1, p1, a_number_string));
        if (!is_t_integer(p2))
            return(wrong_type_argument(sc, sc->number_to_string_symbol, 2, p2, T_INTEGER));
        radix = s7_integer(p2);
        if ((radix < 2) || (radix > 16))
            return(out_of_range(sc, sc->number_to_string_symbol, small_int(2), p2, a_valid_radix_string));

        b = number_to_string_with_radix(sc, p1, radix, 0, sc->float_format_precision, 'g', &nlen);
        return(block_to_string(sc, b, nlen));
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rax
movq %rdi, %rbx
movq $0x0, 0x10(%rsp)
movzbl (%rsi), %edx
leaq 0xc761e(%rip), %rsi     # 0x14a970
cmpb $0x0, (%rdx,%rsi)
je 0x833d0
cmpb $0xb, (%rcx)
jne 0x833f8
movq 0x8(%rcx), %rdx
leaq -0x11(%rdx), %rsi
cmpq $-0x10, %rsi
ja 0x83427
movq 0x1370(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc35db(%rip), %rdx     # 0x146960
movq 0xd22a4(%rip), %rsi     # 0x155630
movq 0x1ee8(%rbx), %rdi
movq 0x10(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x10(%rdi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x38dfa
movq 0x1370(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0xc3576(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %r8
movq 0xd1fb0(%rip), %r9      # 0x1553a0
movq %rbx, %rdi
movq %rax, %rcx
jmp 0x8341b
movq 0x1370(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xc3556(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0xc76a0(%rip), %r9      # 0x14aab8
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xa4e4
movslq 0x468(%rbx), %r8
leaq 0x10(%rsp), %r14
movq %r14, (%rsp)
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x67, %r9d
callq 0xd7ce
movq (%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x37ebe
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_to_number_p_p
static s7_pointer string_to_number_p_p(s7_scheme *sc, s7_pointer str1)
    {
        char *str;
        if (!is_string(str1))
            return(wrong_type_argument(sc, sc->string_to_number_symbol, 1, str1, T_STRING));
        str = (char *)string_value(str1);
        if ((!str) || (!(*str)))
            return(sc->F);
        return(string_to_number(sc, str, 10));
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
cmpb $0x13, (%rsi)
jne 0x834a1
movq 0x10(%rcx), %rsi
testq %rsi, %rsi
je 0x83498
cmpb $0x0, (%rsi)
je 0x83498
movq %rbx, %rdi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0x91b3a
movzbl (%rax), %ecx
leaq 0xc74de(%rip), %rdx     # 0x14a970
cmpb $0x0, (%rcx,%rdx)
jne 0x8349f
movq 0x120(%rbx), %rax
popq %rbx
retq
movq 0x1560(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xc34a5(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %r8
movq 0xc7637(%rip), %r9      # 0x14aaf8
movq %rbx, %rdi
popq %rbx
jmp 0xa4e4
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: string_to_number_p_pp
static s7_pointer string_to_number_p_pp(s7_scheme *sc, s7_pointer str1, s7_pointer radix1)
    {
        s7_int radix;
        char *str;

        if (!is_string(str1))
            return(wrong_type_argument(sc, sc->string_to_number_symbol, 1, str1, T_STRING));

        if (!is_t_integer(radix1))
            return(wrong_type_argument(sc, sc->string_to_number_symbol, 2, radix1, T_INTEGER));
        radix = s7_integer(radix1);
        if ((radix < 2) || (radix > 16))
            return(out_of_range(sc, sc->string_to_number_symbol, small_int(2), radix1, a_valid_radix_string));

        str = (char *)string_value(str1);
        if ((!str) || (!(*str)))
            return(sc->F);

        return(string_to_number(sc, str, radix));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
cmpb $0x13, (%rsi)
jne 0x83555
movq %rdx, %rcx
cmpb $0xb, (%rdx)
jne 0x8357d
movq 0x8(%rcx), %rdx
leaq -0x11(%rdx), %rsi
cmpq $-0x10, %rsi
ja 0x835ac
movq 0x1560(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc3457(%rip), %rdx     # 0x146960
movq 0xd2120(%rip), %rsi     # 0x155630
movq 0x1ee8(%rbx), %rdi
movq 0x10(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x10(%rdi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38dfa
jmp 0x835de
movq 0x1560(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0xc33f1(%rip), %rdx     # 0x146958
movq 0x140(%rbx), %r8
movq 0xc7583(%rip), %r9      # 0x14aaf8
movq %rbx, %rdi
movq %rax, %rcx
jmp 0x835a0
movq 0x1560(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xc33d1(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0xc751b(%rip), %r9      # 0x14aab8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa4e4
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x835d7
cmpb $0x0, (%rsi)
je 0x835d7
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x91b3a
movq %rax, %r14
movzbl (%rax), %eax
leaq 0xc739f(%rip), %rcx     # 0x14a970
cmpb $0x0, (%rax,%rcx)
jne 0x835de
movq 0x120(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0x8364b
movq 0x14a8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc7425(%rip), %r8      # 0x14aa68
movq %r14, %rdx
callq 0xed2a
movq %rbx, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x836bc
movq 0x14b0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc73b4(%rip), %r8      # 0x14aa68
movq %r14, %rdx
callq 0xed2a
movq %rbx, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x836e1
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x836e1
movq 0x8(%rax), %rax
retq
movq 0xca8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc736e(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x83715
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x83715
movq 0x8(%rax), %rax
retq
movq 0xce0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc733a(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x83749
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x83749
movq 0x10(%rax), %rax
retq
movq 0xd60(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc7306(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x8377d
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x8377d
movq 0x10(%rax), %rax
retq
movq 0xd98(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc72d2(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x837ba
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x837ba
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x837ba
movq 0x8(%rax), %rax
retq
movq 0xcd8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc7295(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x83800
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x83800
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x83800
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x83800
movq 0x8(%rax), %rax
retq
movq 0xcc8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc724f(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x8383d
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x8383d
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x8383d
movq 0x8(%rax), %rax
retq
movq 0xca0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc7212(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x83883
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x83883
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x83883
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x83883
movq 0x8(%rax), %rax
retq
movq 0xc98(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc71cc(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x838c0
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x838c0
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x838c0
movq 0x8(%rax), %rax
retq
movq 0xcc0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc718f(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x83906
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x83906
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x83906
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x83906
movq 0x8(%rax), %rax
retq
movq 0xcb8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc7149(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x83943
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x83943
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x83943
movq 0x10(%rax), %rax
retq
movq 0xd58(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xc710c(%rip), %r8      # 0x14aa68
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/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 0x83ad4
cmpq %rbx, %rax
je 0x83b44
movq 0x8(%rbx), %rax
movq 0x48(%rax), %rax
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq *0x8(%rax)
jmp 0x83b44
cmpq %rbx, %rax
je 0x83b44
movq 0x1360(%r14), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x83b06
movq %r14, %rdi
callq 0xa550
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 0xce79d(%rip), %r8      # 0x1522c8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfa261
movq 0xc6f0d(%rip), %rax     # 0x14aa58
movq 0x50(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: 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 0x8420c
movq %rdx, %r14
movq %rdi, %r15
cmpb $0x22, (%rdx)
jne 0x8415f
movq 0x8(%r14), %rax
cmpb $0x1, 0x2(%rax)
jne 0x84117
leaq 0x860b8(%rip), %rsi     # 0x10a1b8
leaq 0x96e7e(%rip), %r8      # 0x11af85
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xd4e5
movzbl (%rbx), %eax
leaq 0xce21f(%rip), %rcx     # 0x152340
cmpb $0x1, (%rax,%rcx)
jne 0x841f0
cmpl $0x15, %eax
jne 0x8413a
testb $0x1, 0x7(%rbx)
jne 0x841f0
cmpq %rbx, 0x150(%r15)
je 0x841f0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x95196
jmp 0x8420c
movq 0x16b8(%r15), %r12
movq 0x90(%r15), %rax
movq 0x110(%r15), %r13
cmpq 0x98(%r15), %rax
ja 0x8418c
movq %r15, %rdi
callq 0xa550
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 0xce0f5(%rip), %r8      # 0x1522c8
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe659
leaq 0xce189(%rip), %r9      # 0x152380
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_O3/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 0x8425d
movq 0x188(%r14), %rdx
cmpq 0x120(%r14), %rdx
je 0x8424e
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 0x8428a
movq %r14, %rdi
callq 0xa550
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 0xe42d
// File: /workspace/github_c_makefile_star2_O3/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 0x84319
cmpq %r15, 0x120(%r14)
je 0x8430c
cmpb $0x22, (%r15)
jne 0x843a9
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 0x84346
movq %r14, %rdi
callq 0xa550
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 0xe42d
movq 0x16a8(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x843d6
movq %r14, %rdi
callq 0xa550
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 0xcdeab(%rip), %r8      # 0x1522c8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x2, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe659
// File: /workspace/github_c_makefile_star2_O3/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 0x847fa
testq %rcx, %rcx
js 0x8481d
cmpq %rcx, 0x8(%rdx)
jle 0x84859
movq 0x10(%rdx), %r15
movsbl 0x8(%rsi), %esi
addq %r15, %rcx
movq %rcx, %rdi
callq 0x81d0
testq %rax, %rax
je 0x84859
movq %rax, %r14
subq %r15, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x84866
leaq 0xc215c(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x84860
movq 0xde0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xc62e5(%rip), %r8      # 0x14aaf8
movq %rbx, %rdi
callq 0xed2a
jmp 0x84859
movq 0xde0(%rbx), %rax
movq 0x8(%rax), %r14
movq 0xc2139(%rip), %r15     # 0x146968
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xd27e
movq 0x140(%rbx), %r8
movq 0xce390(%rip), %r9      # 0x152bd8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xa4e4
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x84885
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0x84860
// File: /workspace/github_c_makefile_star2_O3/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 0x848d8
movq %rbx, %rdi
callq 0xa550
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 0x78b50
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_O3/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 0x85c6d
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
sete %al
movsd 0x804fd(%rip), %xmm1    # 0x1060e0
ucomisd %xmm0, %xmm1
ja 0x85bf7
ucomisd 0x804e7(%rip), %xmm0    # 0x1060d8
ja 0x85bf7
testb %al, %al
je 0x85c5d
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 0xc4e1d(%rip), %rsi     # 0x14aa40
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 0x38dfa
movsd 0x8(%rsp), %xmm0
callq 0xfaab5
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 0xcf9a7(%rip), %rsi     # 0x155640
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 0x38dfa
movsd 0x8(%rsp), %xmm0
jmp 0x85bc1
// File: /workspace/github_c_makefile_star2_O3/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 0x85d74
movapd 0x841ce(%rip), %xmm1    # 0x109ec0
andpd %xmm0, %xmm1
ucomisd 0x803da(%rip), %xmm1    # 0x1060d8
jbe 0x85d64
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 0xc4d14(%rip), %rsi     # 0x14aa40
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 0x38dfa
movapd (%rsp), %xmm0
callq 0x85f0
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 0xcf8a0(%rip), %rsi     # 0x155640
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 0x38dfa
movapd (%rsp), %xmm0
jmp 0x85cea