LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x68d3a
cmpq %r12, 0x2b0(%r14)
jge 0x68d7e
testq %r12, %r12
movq 0x1260(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xacc11(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %r12, 0x8(%rax)
movq 0x1f00(%r14), %rcx
leaq 0xb0ce0(%rip), %rax     # 0x119a48
leaq 0xb0cd1(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
xorl %eax, %eax
movq %r15, %r13
movb (%r13), %cl
cmpb $0x1, %cl
jne 0x68d9a
cmpq %r12, %rax
jge 0x68d9a
incq %rax
movq 0x10(%r13), %r13
jmp 0x68d83
cmpb $0x1, %cl
je 0x68df2
movq 0x1260(%r14), %rax
movq 0x8(%rax), %rsi
cmpb $0x2, %cl
jne 0x68dd9
movq 0xacbaa(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %r12, 0x8(%rax)
movq 0x1f00(%r14), %rcx
movq 0xb0c71(%rip), %r8      # 0x119a40
movq %r14, %rdi
callq 0xcb8f
jmp 0x68df2
movq 0x140(%r14), %rcx
movq 0xb8e31(%rip), %r8      # 0x121c18
movq %r14, %rdi
movq %r15, %rdx
callq 0xd456
movq %rbx, 0x8(%r13)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x68e3a
movq 0x1548(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xb0cc9(%rip), %r8      # 0x119af8
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd456
testq %r15, %r15
js 0x68e5b
cmpq %r15, 0x8(%rbx)
jle 0x68e5b
movq 0xb0c0c(%rip), %rax     # 0x119a58
movq 0x10(%rbx), %rcx
movzbl (%rcx,%r15), %ecx
movq (%rax,%rcx,8), %rbx
jmp 0x68e9f
movq 0x1548(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xacaf3(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %r15, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %r15, %r15
leaq 0xb0bbf(%rip), %rax     # 0x119a48
leaq 0xb0bb0(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x68f22
movq 0x1550(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xb0be1(%rip), %r8      # 0x119af8
movq %r14, %rdi
movq %r12, %rdx
callq 0xd456
cmpb $0x8, (%rbx)
je 0x68f4b
movq 0x1550(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xb0b60(%rip), %r8      # 0x119aa0
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd456
testq %r15, %r15
js 0x68f65
cmpq %r15, 0x8(%r12)
jle 0x68f65
movb 0x8(%rbx), %al
movq 0x10(%r12), %rcx
movb %al, (%rcx,%r15)
jmp 0x68fa9
movq 0x1550(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xac9e9(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %r15, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %r15, %r15
leaq 0xb0ab5(%rip), %rax     # 0x119a48
leaq 0xb0aa6(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x68fdc
cmpq %rdx, 0x8(%rbx)
jle 0x68fdc
movq 0xb0a8a(%rip), %rax     # 0x119a58
movq 0x10(%rbx), %rcx
movzbl (%rcx,%rdx), %ecx
movq (%rax,%rcx,8), %rbx
jmp 0x69020
movq 0x1548(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xac972(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
testq %rdx, %rdx
leaq 0xb0a3e(%rip), %rdx     # 0x119a48
leaq 0xb0a2f(%rip), %r8      # 0x119a40
cmovsq %rdx, %r8
movq (%r8), %r8
movq %rax, %rdx
callq 0xcb8f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x69052
cmpq %r15, 0x8(%rsi)
jle 0x69052
movb 0x8(%rbx), %al
movq 0x10(%rsi), %rcx
movb %al, (%rcx,%r15)
jmp 0x690d9
movq 0x1550(%r14), %rax
movq 0x8(%rax), %r12
movq 0xac8fc(%rip), %r13     # 0x115960
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0x6907a
leaq 0xac8dc(%rip), %rax     # 0x115950
movq (%rax,%r15,8), %rcx
jmp 0x690b3
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x69099
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rcx
movq $0xb, (%rcx)
movq %r15, 0x8(%rcx)
testq %r15, %r15
leaq 0xb098b(%rip), %rax     # 0x119a48
leaq 0xb097c(%rip), %rdx     # 0x119a40
cmovsq %rax, %rdx
movq (%rdx), %r8
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xcb8f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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), %rdi
movzbl (%rsi), %eax
cmpl $0xd, %eax
je 0x69386
cmpl $0xb, %eax
jne 0x693e0
cvtsi2sdq 0x8(%rsi), %xmm0
movsd %xmm0, (%rsp)
callq 0xd0c9
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x69401
leaq 0xac5d3(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x6943a
movsd 0x8(%rsi), %xmm0
movsd %xmm0, (%rsp)
callq 0xd0c9
mulsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x693c3
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x9c27
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 0x6943a
movq 0x700(%rbx), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x59a5d
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x69420
movq %rbx, %rdi
callq 0x9c27
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
andq $0x0, (%rsp)
movzbl (%rsi), %ecx
leaq 0xb04df(%rip), %rdx     # 0x119970
cmpb $0x0, (%rcx,%rdx)
je 0x694ca
movslq 0x468(%rbx), %rcx
pushq $0x67
popq %r8
movq %rsp, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r14, %r9
callq 0x730a4
movq (%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd11d
movq 0x1370(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0xac47c(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0xbaeb6(%rip), %r9      # 0x1243a0
movq %rbx, %rdi
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/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, %rax
movq %rsi, %rcx
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
movzbl (%rsi), %edx
leaq 0xb0454(%rip), %rsi     # 0x119970
cmpb $0x0, (%rdx,%rsi)
je 0x69564
cmpb $0xb, (%rax)
jne 0x69589
movq 0x8(%rax), %rdx
leaq -0x11(%rdx), %rsi
cmpq $-0x10, %rsi
ja 0x695bb
movq 0x1370(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0xac415(%rip), %rdx     # 0x115960
movq 0xbb0de(%rip), %r8      # 0x124630
movq %rbx, %rdi
movq %rax, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xcb8f
movq 0x1370(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xac3e2(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0xbae1c(%rip), %r9      # 0x1243a0
movq %rbx, %rdi
jmp 0x695af
movq 0x1370(%rbx), %rcx
movq 0x8(%rcx), %rsi
movq 0xac3c5(%rip), %rdx     # 0x115960
movq 0x140(%rbx), %r8
movq 0xb050f(%rip), %r9      # 0x119ab8
movq %rbx, %rdi
movq %rax, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x9bbb
movslq 0x468(%rbx), %r8
leaq 0x10(%rsp), %r14
movq %r14, (%rsp)
pushq $0x67
popq %r9
movq %rbx, %rdi
movq %rcx, %rsi
xorl %ecx, %ecx
callq 0xc49c
movq (%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x2bf22
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rcx
cmpb $0x13, (%rsi)
jne 0x6960f
movq 0x10(%rcx), %rsi
testq %rsi, %rsi
je 0x69634
cmpb $0x0, (%rsi)
je 0x69634
pushq $0xa
popq %rdx
jmp 0xc9470
movq 0x1560(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xac337(%rip), %rdx     # 0x115958
movq 0x140(%rdi), %r8
movq 0xb04c9(%rip), %r9      # 0x119af8
jmp 0x9bbb
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rax
cmpb $0x13, (%rsi)
jne 0x69678
movq %rdx, %rcx
cmpb $0xb, (%rdx)
jne 0x696a0
movq 0x8(%rcx), %rdx
leaq -0x11(%rdx), %rsi
cmpq $-0x10, %rsi
ja 0x696c5
movq 0x1560(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xac2f4(%rip), %rdx     # 0x115960
movq 0xbafbd(%rip), %r8      # 0x124630
jmp 0xcb8f
movq 0x1560(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0xac2ce(%rip), %rdx     # 0x115958
movq 0x140(%rdi), %r8
movq 0xb0460(%rip), %r9      # 0x119af8
movq %rax, %rcx
jmp 0x9bbb
movq 0x1560(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xac2ae(%rip), %rdx     # 0x115960
movq 0x140(%rdi), %r8
movq 0xb03f8(%rip), %r9      # 0x119ab8
jmp 0x9bbb
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x696d8
cmpb $0x0, (%rsi)
je 0x696d8
jmp 0xc9470
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x69742
movq 0x14a8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb032e(%rip), %r8      # 0x119a68
movq %r14, %rdx
callq 0xd456
movq %rbx, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x697b3
movq 0x14b0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb02bd(%rip), %r8      # 0x119a68
movq %r14, %rdx
callq 0xd456
movq %rbx, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x697d8
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x697d8
movq 0x8(%rax), %rax
retq
movq 0xca8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb0277(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x6980c
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x6980c
movq 0x8(%rax), %rax
retq
movq 0xce0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb0243(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x69840
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x69840
movq 0x10(%rax), %rax
retq
movq 0xd60(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb020f(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x69874
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x69874
movq 0x10(%rax), %rax
retq
movq 0xd98(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb01db(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x698b1
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x698b1
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x698b1
movq 0x8(%rax), %rax
retq
movq 0xcd8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb019e(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x698f7
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x698f7
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x698f7
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x698f7
movq 0x8(%rax), %rax
retq
movq 0xcc8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb0158(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x69934
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x69934
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x69934
movq 0x8(%rax), %rax
retq
movq 0xca0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb011b(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x6997a
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x6997a
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x6997a
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x6997a
movq 0x8(%rax), %rax
retq
movq 0xc98(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb00d5(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x699b7
movq 0x8(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x699b7
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x699b7
movq 0x8(%rax), %rax
retq
movq 0xcc0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb0098(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x699fd
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x699fd
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x699fd
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x699fd
movq 0x8(%rax), %rax
retq
movq 0xcb8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb0052(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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 0x69a3a
movq 0x10(%rdx), %rax
cmpb $0x1, (%rax)
jne 0x69a3a
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x69a3a
movq 0x10(%rax), %rax
retq
movq 0xd58(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rdi), %rcx
movq 0xb0015(%rip), %r8      # 0x119a68
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/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)
jne 0x69af7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c000
jmp 0x69b6b
cmpq %rbx, 0x120(%r14)
je 0x69b6b
movq 0x1360(%r14), %r15
movq 0x90(%r14), %rax
movq 0x110(%r14), %r12
cmpq 0x98(%r14), %rax
ja 0x69b2d
movq %r14, %rdi
callq 0x9c27
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 0xb7776(%rip), %r8      # 0x1212c8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc736d
movq 0xafee6(%rip), %rax     # 0x119a58
movq 0x50(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: display_p_pp
static s7_pointer display_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->display_symbol, list_2(sc, x, port), an_output_port_string, 2));
        if (port_is_closed(port))
            s7_wrong_type_arg_error(sc, "display", 2, port, "an open output port");
        check_method(sc, x, sc->display_symbol, list_2(sc, x, port));
        return(object_out(sc, x, port, P_DISPLAY));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
cmpq %rdx, 0x120(%rdi)
je 0x69e20
movq %rdx, %r15
movq %rdi, %rbx
cmpb $0x22, (%rdx)
jne 0x69d81
movq 0x8(%r15), %rax
cmpb $0x1, 0x2(%rax)
jne 0x69cb7
leaq 0x6c4bc(%rip), %rsi     # 0xd615e
leaq 0x7d27c(%rip), %r8      # 0xe6f25
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq 0xc2b0
testb $0x40, 0x3(%r14)
je 0x69e10
cmpb $0x1, 0x24c(%rbx)
jne 0x69e10
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0xe80(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0x69e10
movq %rax, %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x69d22
movq %rbx, %rdi
callq 0x9c27
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 %r13, 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 %rbx, %rdi
callq 0x35492
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa34c
movq 0xe80(%rbx), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x69dae
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0xb74d3(%rip), %r8      # 0x1212c8
pushq $0x2
popq %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x2ba5b
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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, %r14
cmpq %rdx, 0x120(%rdi)
je 0x69ea8
movq %rdx, %rbx
movq %rdi, %r15
cmpb $0x22, (%rdx)
jne 0x69eb5
movq 0x8(%rbx), %rax
cmpb $0x1, 0x2(%rax)
jne 0x69e97
leaq 0x6c2d6(%rip), %rsi     # 0xd6158
leaq 0x7d09c(%rip), %r8      # 0xe6f25
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0xc2b0
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ba5b
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x16b8(%r15), %r12
movq 0x90(%r15), %rax
movq 0x110(%r15), %r13
cmpq 0x98(%r15), %rax
ja 0x69ee2
movq %r15, %rdi
callq 0x9c27
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 %rbx, 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 %r14, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0xb739f(%rip), %r8      # 0x1212c8
pushq $0x2
popq %r9
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/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 0x69f88
movq 0x188(%r14), %rdx
cmpq 0x120(%r14), %rdx
je 0x69f79
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 0x69fb5
movq %r14, %rdi
callq 0x9c27
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)
pushq $0x8
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/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 0x6a040
cmpq %r15, 0x120(%r14)
je 0x6a033
cmpb $0x22, (%r15)
jne 0x6a0cc
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 0x6a06d
movq %r14, %rdi
callq 0x9c27
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)
pushq $0x8
popq %r8
pushq $0x1
popq %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcd70
movq 0x16a8(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x6a0f9
movq %r14, %rdi
callq 0x9c27
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 0xb7188(%rip), %r8      # 0x1212c8
pushq $0x2
popq %r9
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcf9a
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: inlet_p_pp
static s7_pointer inlet_p_pp(s7_scheme *sc, s7_pointer symbol, s7_pointer value)
    {
        s7_pointer x, slot;

        if (!is_symbol(symbol))
            return(sublet_1(sc, sc->nil, list_2(sc, symbol, value), sc->inlet_symbol));
        if (is_keyword(symbol))
            symbol = keyword_symbol(symbol);
        if (is_constant_symbol(sc, symbol))
            return(wrong_type_argument_with_type(sc, sc->inlet_symbol, 1, symbol, a_non_constant_symbol_string));

        new_cell(sc, x, T_LET | T_SAFE_PROCEDURE);
        sc->temp3 = x;
        let_id(x) = ++sc->let_number;
        set_outlet(x, sc->nil);
        new_cell_no_check(sc, slot, T_SLOT);
        slot_set_symbol(slot, symbol);
        slot_set_value(slot, value);
        slot_set_next(slot, slot_end(sc));
        let_set_slots(x, slot);
        set_local(symbol);
        symbol_set_local(symbol, let_id(x), slot);
        sc->temp3 = sc->nil;
        return(x);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0xa, (%rsi)
jne 0x6a29f
testb $-0x80, 0x6(%r14)
je 0x6a256
movq 0x8(%r14), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72bfa
testb %al, %al
je 0x6a322
movq 0xfa0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xab6dd(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0xb2c2f(%rip), %r9      # 0x11ceb8
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9bbb
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x6a2c5
movq %rbx, %rdi
callq 0x9c27
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), %rdx
movq %rcx, (%rdx)
movq %r14, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq 0xfa0(%rbx), %rcx
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9c6e
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6a341
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x20001c, (%rax)       # imm = 0x20001C
movq %rax, 0x508(%rbx)
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq $0x20, (%rcx)
movq %r14, 0x8(%rcx)
movq %r15, 0x10(%rcx)
andq $0x0, 0x18(%rcx)
movq %rcx, 0x8(%rax)
movq $-0x112201, %rdx        # imm = 0xFFEEDDFF
andq (%r14), %rdx
orq $0x100000, %rdx         # imm = 0x100000
movq %rdx, (%r14)
movq %rcx, 0x18(%r14)
movq 0x18(%rax), %rcx
movq %rcx, 0x20(%r14)
incl 0x28(%r14)
movq 0x110(%rbx), %rcx
movq %rcx, 0x508(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x6a4a1
testq %rcx, %rcx
js 0x6a4c4
cmpq %rcx, 0x8(%rdx)
jle 0x6a500
movq 0x10(%rdx), %r15
movsbl 0x8(%rsi), %esi
addq %r15, %rcx
movq %rcx, %rdi
callq 0x81d0
testq %rax, %rax
je 0x6a500
movq %rax, %r14
subq %r15, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x6a50d
leaq 0xab4b5(%rip), %rax     # 0x115950
movq (%rax,%r14,8), %rax
jmp 0x6a507
movq 0xde0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xaf63e(%rip), %r8      # 0x119af8
movq %rbx, %rdi
callq 0xd456
jmp 0x6a500
movq 0xde0(%rbx), %rax
movq 0x8(%rax), %r14
movq 0xab492(%rip), %r15     # 0x115968
movq %rbx, %rdi
movq %rcx, %rsi
callq 0xc049
movq 0x140(%rbx), %r8
movq 0xb76e9(%rip), %r9      # 0x121bd8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x9bbb
movq 0x120(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6a52c
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0x6a507
// File: /workspace/github_c_makefile_star2_O2/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 0x6a57f
movq %rbx, %rdi
callq 0x9c27
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 0x61b3f
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_O2/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 0x6b81b
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
sete %al
movsd 0x6691a(%rip), %xmm1    # 0xd20d8
ucomisd %xmm0, %xmm1
ja 0x6b7d2
ucomisd 0x66904(%rip), %xmm0    # 0xd20d0
ja 0x6b7d2
testb %al, %al
je 0x6b80b
movq 0x1498(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x1f18(%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq 0x1f18(%rbx), %rdx
movq 0xae249(%rip), %rcx     # 0x119a40
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x35b47
movsd 0x8(%rsp), %xmm0
callq 0xc7bfc
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
retq
movq 0x1498(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x1f18(%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq 0x1f18(%rbx), %rdx
movq 0xb8e00(%rip), %rcx     # 0x124640
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x35b47
movsd 0x8(%rsp), %xmm0
jmp 0x6b79c
// File: /workspace/github_c_makefile_star2_O2/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 0x6b8c4
movapd 0x6a651(%rip), %xmm1    # 0xd5ec0
andpd %xmm0, %xmm1
ucomisd 0x66855(%rip), %xmm1    # 0xd20d0
jbe 0x6b8b4
movq 0xf08(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x1f18(%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq 0x1f18(%rbx), %rdx
movq 0xae19e(%rip), %rcx     # 0x119a40
movq %rbx, %rdi
movapd %xmm0, (%rsp)
callq 0x35b47
movapd (%rsp), %xmm0
callq 0x85f0
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
retq
movq 0xf08(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x1f18(%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq 0x1f18(%rbx), %rdx
movq 0xb8d57(%rip), %rcx     # 0x124640
movq %rbx, %rdi
movapd %xmm0, (%rsp)
callq 0x35b47
movapd (%rsp), %xmm0
jmp 0x6b867
// File: /workspace/github_c_makefile_star2_O2/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 0x6b963
cmpl $0xc, %eax
je 0x6b92e
cmpl $0xb, %eax
jne 0x6b97d
movq 0x8(%rbx), %r15
jmp 0x6ba1d
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 0x85f0
cvttsd2si %xmm0, %r15
jmp 0x6ba1d
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6b859
testb $0x40, 0x3(%rbx)
je 0x6b9ff
cmpb $0x1, 0x24c(%r14)
jne 0x6b9ff
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88f3
movq %rax, %r15
movq 0xf08(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x6b9c8
movq %r14, %rdi
callq 0x9c27
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 0x73dc9
cmpb $0xb, (%rax)
jne 0x6ba2e
movq 0x8(%rax), %r15
jmp 0x6ba1d
leaq 0x6ef25(%rip), %rsi     # 0xda92b
leaq 0x6bde4(%rip), %r8      # 0xd77f1
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xc2b0
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x6ba1d
// File: /workspace/github_c_makefile_star2_O2/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 0x6ba96
cmpl $0xc, %eax
je 0x6ba61
cmpl $0xb, %eax
jne 0x6bab0
movq 0x8(%rbx), %r15
jmp 0x6bb50
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 0x86c0
cvttsd2si %xmm0, %r15
jmp 0x6bb50
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6bcb7
testb $0x40, 0x3(%rbx)
je 0x6bb32
cmpb $0x1, 0x24c(%r14)
jne 0x6bb32
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88f3
movq %rax, %r15
movq 0xda8(%r14), %r12
movq 0x90(%r14), %rax
movq 0x110(%r14), %r13
cmpq 0x98(%r14), %rax
ja 0x6bafb
movq %r14, %rdi
callq 0x9c27
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 0x73dc9
cmpb $0xb, (%rax)
jne 0x6bb61
movq 0x8(%rax), %r15
jmp 0x6bb50
leaq 0x6ee2f(%rip), %rsi     # 0xda968
leaq 0x6bcb1(%rip), %r8      # 0xd77f1
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xc2b0
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r15d, %r15d
jmp 0x6bb50