LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: char_equal_chooser
static s7_pointer char_equal_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if (args == 2)
                    {
                        if (ops)
                        {
                            s7_pointer arg1, arg2;
                            arg1 = cadr(expr);
                            arg2 = caddr(expr);
                            if ((returns_char(sc, arg1)) && (returns_char(sc, arg2)))
                                return(sc->simple_char_eq);
                        }
                        return(sc->char_equal_2);
                    }
                    return(f);
                }

// Assembly:
movq %rsi, %rax
cmpl $0x2, %edx
jne 0x1016e3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testb %r8b, %r8b
je 0x1016d5
movq 0x10(%rcx), %r15
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x103f3e
cmpq 0x1020(%rbx), %rax
jne 0x1016d5
movq %rax, %r14
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x103f3e
cmpq %r14, %rax
je 0x1016e4
movl $0x1aa0, %eax           # imm = 0x1AA0
movq (%rbx,%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1a98, %eax           # imm = 0x1A98
jmp 0x1016da
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_char_greater_2
static s7_pointer g_char_greater_2(s7_scheme *sc, s7_pointer args)
    {
        if (!s7_is_character(car(args)))
            return(method_or_bust(sc, car(args), sc->char_gt_symbol, args, T_CHARACTER, 1));
        if (!s7_is_character(cadr(args)))
            return(method_or_bust(sc, cadr(args), sc->char_gt_symbol, args, T_CHARACTER, 2));
        return(make_boolean(sc, character(car(args)) > character(cadr(args))));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x101748
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0x8, (%rax)
jne 0x101760
movb 0x8(%rsi), %cl
xorl %edx, %edx
cmpb 0x8(%rax), %cl
setbe %dl
movq 0x118(%rdi,%rdx,8), %rax
retq
movq 0xdc8(%rdi), %rdx
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0xe42d
movq 0xdc8(%rdi), %rdx
movq %rax, %rsi
movl $0x8, %r8d
movl $0x2, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_char_less_2
static s7_pointer g_char_less_2(s7_scheme *sc, s7_pointer args)
    {
        if (!s7_is_character(car(args)))
            return(method_or_bust(sc, car(args), sc->char_lt_symbol, args, T_CHARACTER, 1));
        if (!s7_is_character(cadr(args)))
            return(method_or_bust(sc, cadr(args), sc->char_lt_symbol, args, T_CHARACTER, 2));
        return(make_boolean(sc, character(car(args)) < character(cadr(args))));
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x8, (%rsi)
jne 0x1017b8
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0x8, (%rax)
jne 0x1017d0
movb 0x8(%rsi), %cl
xorl %edx, %edx
cmpb 0x8(%rax), %cl
setae %dl
movq 0x118(%rdi,%rdx,8), %rax
retq
movq 0xdd8(%rdi), %rdx
movl $0x8, %r8d
movl $0x1, %r9d
jmp 0xe42d
movq 0xdd8(%rdi), %rdx
movq %rax, %rsi
movl $0x8, %r8d
movl $0x2, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_read_char_1
static s7_pointer g_read_char_1(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer port;
        port = car(args);
        if (!is_input_port(port))
            return(method_or_bust_with_type_one_arg(sc, port, sc->read_char_symbol, args, an_input_port_string));
        return(chars[port_read_character(port)(sc, port)]);
    }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x23, (%rsi)
jne 0x101821
pushq %rbx
movq 0x49249(%rip), %rbx     # 0x14aa58
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
callq *(%rax)
cltq
movq (%rbx,%rax,8), %rax
popq %rbx
retq
movq 0x1448(%rdi), %rdx
movq 0x493d1(%rip), %r8      # 0x14ac00
jmp 0xfa261
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: char_position_chooser
static s7_pointer char_position_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if (!ops) return(f);
                    if (((args == 2) || (args == 3)) &&
                            (s7_is_character(cadr(expr))))
                        return(sc->char_position_csi);
                    return(f);
                }

// Assembly:
movq %rsi, %rax
xorb $0x1, %r8b
andl $-0x2, %edx
cmpl $0x2, %edx
setne %dl
orb %r8b, %dl
jne 0x10185d
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpb $0x8, (%rcx)
jne 0x10185d
movq 0x1ab8(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_char_position_csi
static s7_pointer g_char_position_csi(s7_scheme *sc, s7_pointer args)
    {
        /* assume char arg1, no end */
        const char *porig, *p;
        char c;
        s7_pointer arg2;
        s7_int start, len;

        c = character(car(args));
        arg2 = cadr(args);

        if (!is_string(arg2))
            return(g_char_position(sc, args));

        len = string_length(arg2); /* can't return #f here if len==0 -- need start error check first */
        porig = string_value(arg2);

        if (is_pair(cddr(args)))
        {
            s7_pointer arg3;
            arg3 = caddr(args);
            if (!s7_is_integer(arg3))
                return(g_char_position(sc, args));
            start = s7_integer(arg3);
            if (start < 0)
                return(wrong_type_argument_with_type(sc, sc->char_position_symbol, 3, arg3, a_non_negative_integer_string));
            if (start >= len) return(sc->F);
        }
        else start = 0;

        if (len == 0) return(sc->F);
        p = strchr((const char *)(porig + start), (int)c);
        if (p)
            return(make_integer(sc, p - porig));
        return(sc->F);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rdi
cmpb $0x13, (%rdi)
jne 0x1018ac
movq 0x8(%rax), %rdx
movsbl 0x8(%rdx), %esi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %r15
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x1018bc
movq 0x8(%rcx), %rcx
cmpb $0xb, (%rcx)
jne 0x1018ac
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
js 0x101934
cmpq %rdx, %rdi
jl 0x1018c3
jmp 0x1018ec
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x70510
testq %rdx, %rdx
je 0x1018ec
xorl %edi, %edi
addq %r15, %rdi
callq 0x81d0
testq %rax, %rax
je 0x1018ec
movq %rax, %r14
subq %r15, %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x1018f5
leaq 0x4506a(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x10192e
movq 0x120(%rbx), %rax
jmp 0x10192e
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x101914
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)
popq %rbx
popq %r14
popq %r15
retq
movq 0xde0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x45022(%rip), %rdx     # 0x146968
movq 0x140(%rbx), %r8
movq 0x51284(%rip), %r9      # 0x152bd8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa4e4
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_equal_2
static s7_pointer g_string_equal_2(s7_scheme *sc, s7_pointer args)
    {
        if (!is_string(car(args)))
            return(method_or_bust(sc, car(args), sc->string_eq_symbol, args, T_STRING, 1));
        if (!is_string(cadr(args)))
            return(method_or_bust(sc, cadr(args), sc->string_eq_symbol, args, T_STRING, 2));
        return(make_boolean(sc, scheme_strings_are_equal(car(args), cadr(args))));
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x1019d5
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0x13, (%rax)
jne 0x1019ed
movq 0x8(%rsi), %rdx
movl $0x120, %ecx            # imm = 0x120
cmpq 0x8(%rax), %rdx
jne 0x1019cf
movq 0x10(%rsi), %rdi
movq 0x10(%rax), %rsi
callq 0x8c146
xorb $0x1, %al
movzbl %al, %eax
leaq 0x118(,%rax,8), %rcx
movq (%rbx,%rcx), %rax
popq %rbx
retq
movq 0x1510(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0x101a06
movq 0x1510(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x13, %r8d
movl $0x2, %r9d
popq %rbx
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_substring_to_temp
static s7_pointer g_substring_to_temp(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer str;
        s7_int start = 0, end;

        str = car(args);
        if (!is_string(str))
            return(method_or_bust(sc, str, sc->substring_symbol, args, T_STRING, 1));

        end = string_length(str);
        if (!is_null(cdr(args)))
        {
            s7_pointer x;
            x = start_and_end(sc, sc->substring_symbol, args, 2, &start, &end);
            if (x != sc->unused) return(x);
        }
        return(wrap_string(sc, (char *)(string_value(str) + start), end - start));
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq $0x0, 0x10(%rsp)
movq 0x8(%rsi), %r14
cmpb $0x13, (%r14)
jne 0x101a78
movq 0x8(%r14), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rax
cmpq 0x110(%rbx), %rax
je 0x101a9d
movq 0x1580(%rbx), %rsi
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %rcx, %rdx
movl $0x2, %ecx
callq 0x9a55e
cmpq 0x140(%rbx), %rax
jne 0x101acb
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
jmp 0x101a9f
movq 0x1580(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xe42d
xorl %ecx, %ecx
subq %rcx, %rdx
addq 0x10(%r14), %rcx
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rsi
movq (%rax,%rsi,8), %rax
incl %esi
andl $0x7, %esi
movl %esi, 0x7dc(%rbx)
movq %rcx, 0x10(%rax)
movq %rdx, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_greater_2
static s7_pointer g_string_greater_2(s7_scheme *sc, s7_pointer args)
    {
        if (!is_string(car(args)))
            return(method_or_bust(sc, car(args), sc->string_gt_symbol, args, T_STRING, 1));
        if (!is_string(cadr(args)))
            return(method_or_bust(sc, cadr(args), sc->string_gt_symbol, args, T_STRING, 2));
        return(make_boolean(sc, scheme_strcmp(car(args), cadr(args)) == 1));
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x101b3f
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0x13, (%rax)
jne 0x101b57
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0xfca5a
xorl %ecx, %ecx
cmpl $0x1, %eax
setne %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x1528(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0x101b70
movq 0x1528(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x13, %r8d
movl $0x2, %r9d
popq %rbx
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_string_less_2
static s7_pointer g_string_less_2(s7_scheme *sc, s7_pointer args)
    {
        if (!is_string(car(args)))
            return(method_or_bust(sc, car(args), sc->string_lt_symbol, args, T_STRING, 1));
        if (!is_string(cadr(args)))
            return(method_or_bust(sc, cadr(args), sc->string_lt_symbol, args, T_STRING, 2));
        return(make_boolean(sc, scheme_strcmp(car(args), cadr(args)) == -1));
    }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x13, (%rsi)
jne 0x101be2
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0x13, (%rax)
jne 0x101bfa
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0xfca5a
xorl %ecx, %ecx
cmpl $-0x1, %eax
setne %cl
movq 0x118(%rbx,%rcx,8), %rax
popq %rbx
retq
movq 0x1538(%rbx), %rdx
movq %rbx, %rdi
movl $0x13, %r8d
movl $0x1, %r9d
jmp 0x101c13
movq 0x1538(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x13, %r8d
movl $0x2, %r9d
popq %rbx
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_vector_ref_3
static s7_pointer g_vector_ref_3(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer vec, i1, i2;
                    s7_int ix, iy;

                    vec = car(args);
                    if (!is_any_vector(vec))
                        return(g_vector_ref(sc, args));
                    if (vector_rank(vec) != 2)
                        return(g_vector_ref(sc, args));

                    i1 = cadr(args);
                    if (!s7_is_integer(i1))
                        return(g_vector_ref(sc, args));
                    i2 = caddr(args);
                    if (!s7_is_integer(i2))
                        return(g_vector_ref(sc, args));
                    ix = s7_integer(i1);
                    iy = s7_integer(i2);
                    if ((ix >= 0) &&
                            (iy >= 0) &&
                            (ix < vector_dimension(vec, 0)) &&
                            (iy < vector_dimension(vec, 1)))
                    {
                        s7_int index;
                        index = (ix * vector_offset(vec, 0)) + iy; /* vector_offset(vec, 1) == 1 */
                        return(vector_getter(vec)(sc, vec, index));
                    }
                    return(g_vector_ref(sc, args));
                }

// Assembly:
movq 0x8(%rsi), %rax
movzbl (%rax), %ecx
leaq 0x48c65(%rip), %rdx     # 0x14ac20
cmpb $0x0, (%rcx,%rdx)
je 0x79c8d
movq 0x18(%rax), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x79c8d
cmpq $0x2, 0x10(%rcx)
jne 0x79c8d
movq 0x10(%rsi), %r8
movq 0x8(%r8), %rdx
cmpb $0xb, (%rdx)
jne 0x79c8d
movq 0x10(%r8), %r8
movq 0x8(%r8), %r8
cmpb $0xb, (%r8)
jne 0x79c8d
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0x79c8d
movq 0x8(%r8), %r8
testq %r8, %r8
js 0x79c8d
movq (%rcx), %r9
cmpq (%r9), %rdx
jge 0x79c8d
cmpq 0x8(%r9), %r8
jge 0x102044
movq 0x18(%rcx), %rcx
imulq (%rcx), %rdx
addq %r8, %rdx
movq 0x20(%rax), %rcx
movq %rax, %rsi
jmpq *%rcx
jmp 0x79c8d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: float_vector_set_chooser
static s7_pointer float_vector_set_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if (args == 3)
                    {
                        if (find_matching_ref(sc, sc->float_vector_ref_symbol, expr))
                            return(sc->fv_set_unchecked);
                        return(sc->fv_set_3);
                    }
                    return(f);
                }

// Assembly:
movq %rsi, %rax
cmpl $0x3, %edx
jne 0x102321
pushq %r14
pushq %rbx
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rcx
movl $0x1b30, %eax           # imm = 0x1B30
cmpb $0xa, (%rcx)
jne 0x10231a
movq 0x10(%rdx), %rsi
movq 0x8(%rsi), %rdx
cmpb $0x1, (%rdx)
je 0x10231a
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %rsi
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0x10231a
movq 0xef0(%rdi), %r8
movq 0x8(%rsi), %r9
cmpb $0x1, (%r9)
jne 0x102311
movq 0x8(%r9), %r10
cmpq %r8, %r10
jne 0x1022ef
movq 0x10(%r9), %r11
cmpb $0x1, (%r11)
jne 0x1022ef
movq 0x10(%r11), %rbx
cmpb $0x1, (%rbx)
jne 0x1022ef
movq 0x10(%rbx), %r14
cmpq 0x110(%rdi), %r14
jne 0x1022ef
cmpq %rcx, 0x8(%r11)
jne 0x1022ef
cmpq %rdx, 0x8(%rbx)
je 0x102322
cmpq %rcx, %r10
jne 0x102311
movq 0x10(%r9), %r9
cmpb $0x1, (%r9)
jne 0x102311
movq 0x10(%r9), %r10
cmpq 0x110(%rdi), %r10
jne 0x102311
cmpq %rdx, 0x8(%r9)
je 0x102322
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
je 0x1022b0
movq (%rdi,%rax), %rax
popq %rbx
popq %r14
retq
movl $0x1b38, %eax           # imm = 0x1B38
jmp 0x10231a
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_fv_set_unchecked
static s7_pointer g_fv_set_unchecked(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer fv, value;
                    s7_int ind;
                    value = caddr(args);
                    if (!s7_is_real(value))
                        return(wrong_type_argument(sc, sc->float_vector_set_symbol, 3, value, T_REAL));
                    fv = car(args);
                    if (is_immutable_vector(fv))
                        return(immutable_object_error(sc, set_elist_3(sc, immutable_error_string, sc->float_vector_set_symbol, fv)));
                    ind = s7_integer(cadr(args));
                    float_vector(fv, ind) = s7_real(value);
                    return(value);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rcx
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rbx
movzbl (%rbx), %eax
leaq 0x484c0(%rip), %rdx     # 0x14a9b0
cmpb $0x0, (%rax,%rdx)
je 0x102510
movq 0x8(%rsi), %r14
testb $0x1, 0x3(%r14)
jne 0x10253d
movq 0x8(%rcx), %rcx
cmpb $0xb, (%rcx)
jne 0x10257e
movq 0x8(%rcx), %r15
jmp 0x102581
movq 0xef8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x44446(%rip), %rdx     # 0x146968
movq 0x140(%rdi), %r8
movq 0x48598(%rip), %r9      # 0x14aac8
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xa4e4
movq 0x48424(%rip), %rax     # 0x14a968
movq 0xef8(%rdi), %rcx
movq 0x6e8(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e8(%rdi), %rdx
movq 0xea8(%rdi), %rbx
movq %rbx, %rsi
callq 0x38dfa
jmp 0x1025ac
xorl %r15d, %r15d
cmpb $0xd, %al
jne 0x10258c
movsd 0x8(%rbx), %xmm0
jmp 0x1025a2
movq 0x4849d(%rip), %rdi     # 0x14aa30
leaq 0x7ade(%rip), %rdx      # 0x10a078
movq %rbx, %rsi
callq 0xd498
movq 0x10(%r14), %rax
movsd %xmm0, (%rax,%r15,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_iv_set_3
static s7_pointer g_iv_set_3(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer v, index, value;
                    s7_int ind;
                    v = car(args);
                    if (!is_int_vector(v))
                        return(method_or_bust(sc, v, sc->int_vector_set_symbol, args, T_INT_VECTOR, 1));
                    if (vector_rank(v) != 1)
                        return(univect_set(sc, args, sc->int_vector_set_symbol, T_INT_VECTOR));
                    index = cadr(args);
                    if (!s7_is_integer(index))
                        return(method_or_bust(sc, index, sc->int_vector_set_symbol, args, T_INTEGER, 2));
                    ind = s7_integer(index);
                    if ((ind < 0) || (ind >= vector_length(v)))
                        return(simple_out_of_range(sc, sc->int_vector_set_symbol, index, (ind < 0) ? its_negative_string : its_too_large_string));
                    value = caddr(args);
                    if (!s7_is_integer(value))
                        return(method_or_bust(sc, value, sc->int_vector_set_symbol, args, T_INTEGER, 3));
                    if (is_immutable_vector(v))
                        return(immutable_object_error(sc, set_elist_3(sc, immutable_error_string, sc->int_vector_set_symbol, v)));
                    int_vector(v, ind) = s7_integer(value);
                    return(value);
                }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x16, (%rsi)
jne 0x102833
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1027eb
cmpq $0x1, 0x10(%rax)
jne 0x102864
movq 0x10(%rcx), %r8
movq 0x8(%r8), %rax
cmpb $0xb, (%rax)
jne 0x102848
movq 0x8(%rax), %rdx
testq %rdx, %rdx
js 0x102879
cmpq 0x8(%rsi), %rdx
jge 0x102879
movq 0x10(%r8), %rax
movq 0x8(%rax), %rbx
cmpb $0xb, (%rbx)
jne 0x1028d6
testb $0x1, 0x3(%rsi)
jne 0x1028f1
movq 0x8(%rbx), %rax
movq 0x10(%rsi), %rcx
movq %rax, (%rcx,%rdx,8)
jmp 0x1028d1
movq 0xfb0(%rdi), %rdx
movl $0x16, %r8d
movl $0x1, %r9d
jmp 0x10285e
movq 0xfb0(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
popq %rbx
jmp 0xe42d
movq 0xfb0(%rdi), %rdx
movq %rcx, %rsi
movl $0x16, %ecx
popq %rbx
jmp 0xfec8b
testq %rdx, %rdx
movq 0xfb0(%rdi), %rcx
movq 0x8(%rcx), %rcx
leaq 0x481ba(%rip), %rdx     # 0x14aa48
leaq 0x481ab(%rip), %rsi     # 0x14aa40
cmovsq %rdx, %rsi
movq (%rsi), %rdx
movq 0x1ef8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %rcx, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ef8(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
movq 0xfb0(%rdi), %rdx
movq %rbx, %rsi
movl $0xb, %r8d
movl $0x3, %r9d
jmp 0x10285e
movq 0x48070(%rip), %rax     # 0x14a968
movq 0xfb0(%rdi), %rcx
movq 0x6e8(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x6e8(%rdi), %rdx
movq 0xea8(%rdi), %rbx
jmp 0x1028c9
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_bv_ref_2
static s7_pointer g_bv_ref_2(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer v, index;
                    s7_int ind;
                    v = car(args);
                    if (!is_byte_vector(v))
                        return(method_or_bust(sc, v, sc->byte_vector_ref_symbol, args, T_BYTE_VECTOR, 1));
                    if (vector_rank(v) != 1)
                        return(univect_ref(sc, args, sc->byte_vector_ref_symbol, T_BYTE_VECTOR));
                    index = cadr(args);
                    if (!s7_is_integer(index))
                        return(method_or_bust(sc, index, sc->byte_vector_ref_symbol, args, T_INTEGER, 2));
                    ind = s7_integer(index);
                    if ((ind < 0) || (ind >= vector_length(v)))
                        return(simple_out_of_range(sc, sc->byte_vector_ref_symbol, index, (ind < 0) ? its_negative_string : its_too_large_string));
                    return(make_integer(sc, byte_vector(v, ind)));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x18, (%rsi)
jne 0x10299d
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x102968
cmpq $0x1, 0x10(%rax)
jne 0x1029d0
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x1029b5
pushq %rbx
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0x1029e4
cmpq 0x8(%rsi), %rcx
jge 0x1029e4
movq 0x10(%rsi), %rax
movzbl (%rax,%rcx), %eax
leaq 0x43fbc(%rip), %rcx     # 0x146950
movq (%rcx,%rax,8), %rbx
jmp 0x102a3c
movq 0xc30(%rdi), %rdx
movl $0x18, %r8d
movl $0x1, %r9d
jmp 0xe42d
movq 0xc30(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
jmp 0xe42d
movq 0xc30(%rdi), %rdx
movq %rcx, %rsi
movl $0x18, %ecx
jmp 0xd6155
testq %rcx, %rcx
movq 0xc30(%rdi), %rcx
movq 0x8(%rcx), %rcx
leaq 0x4804f(%rip), %rdx     # 0x14aa48
leaq 0x48040(%rip), %rsi     # 0x14aa40
cmovsq %rdx, %rsi
movq (%rsi), %rdx
movq 0x1ef8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %rcx, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ef8(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_bv_ref_3
static s7_pointer g_bv_ref_3(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer iv, index;
                    s7_int ind1, ind2;
                    iv = car(args);
                    if (!is_byte_vector(iv))
                        return(method_or_bust(sc, iv, sc->byte_vector_ref_symbol, args, T_BYTE_VECTOR, 1));
                    if (vector_rank(iv) != 2)
                        return(univect_ref(sc, args, sc->byte_vector_ref_symbol, T_BYTE_VECTOR));
                    index = cadr(args);
                    if (!s7_is_integer(index))
                        return(method_or_bust(sc, index, sc->byte_vector_ref_symbol, args, T_INTEGER, 2));
                    ind1 = s7_integer(index);
                    if ((ind1 < 0) || (ind1 >= vector_dimension(iv, 0)))
                        return(simple_out_of_range(sc, sc->byte_vector_ref_symbol, index, (ind1 < 0) ? its_negative_string : its_too_large_string));
                    index = caddr(args);
                    if (!s7_is_integer(index))
                        return(method_or_bust(sc, index, sc->byte_vector_ref_symbol, args, T_INTEGER, 3));
                    ind2 = s7_integer(index);
                    if ((ind2 < 0) || (ind2 >= vector_dimension(iv, 1)))
                        return(simple_out_of_range(sc, sc->byte_vector_ref_symbol, index, (ind2 < 0) ? its_negative_string : its_too_large_string));
                    ind1 = ind1 * vector_offset(iv, 0) + ind2;
                    return(make_integer(sc, byte_vector(iv, ind1)));
                }

// Assembly:
pushq %rbx
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x18, (%rsi)
jne 0x102ae1
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0x102afa
cmpq $0x2, 0x10(%rdx)
jne 0x102afa
movq 0x10(%rcx), %r9
movq 0x8(%r9), %rax
cmpb $0xb, (%rax)
jne 0x102b0f
movq 0x8(%rax), %r8
testq %r8, %r8
js 0x102b27
movq (%rdx), %r10
cmpq (%r10), %r8
jge 0x102b27
movq 0x10(%r9), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x102b84
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0x102b9f
cmpq 0x8(%r10), %rcx
jge 0x102b9f
movq 0x18(%rdx), %rax
imulq (%rax), %r8
addq 0x10(%rsi), %r8
movzbl (%rcx,%r8), %eax
leaq 0x43e78(%rip), %rcx     # 0x146950
movq (%rcx,%rax,8), %rbx
jmp 0x102b7f
movq 0xc30(%rdi), %rdx
movl $0x18, %r8d
movl $0x1, %r9d
popq %rbx
jmp 0xe42d
movq 0xc30(%rdi), %rdx
movq %rcx, %rsi
movl $0x18, %ecx
popq %rbx
jmp 0xd6155
movq 0xc30(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
jmp 0x102af4
testq %r8, %r8
movq 0xc30(%rdi), %rcx
movq 0x8(%rcx), %rcx
leaq 0x47f0c(%rip), %rdx     # 0x14aa48
leaq 0x47efd(%rip), %rsi     # 0x14aa40
cmovsq %rdx, %rsi
movq (%rsi), %rdx
movq 0x1ef8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %rcx, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ef8(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
movq 0xc30(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x3, %r9d
jmp 0x102af4
testq %rcx, %rcx
jmp 0x102b2a
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: list_set_chooser
static s7_pointer list_set_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if ((args == 3) &&
                            (s7_is_integer(caddr(expr))) &&
                            (s7_integer(caddr(expr)) >= 0) &&
                            (s7_integer(caddr(expr)) < sc->max_list_length))
                        return(sc->list_set_i);
                    return(f);
                }

// Assembly:
movq %rsi, %rax
cmpl $0x3, %edx
jne 0x102dbc
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpb $0xb, (%rcx)
jne 0x102dbc
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
js 0x102dbc
cmpq 0x2b0(%rdi), %rcx
jge 0x102dbc
movq 0x1b98(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table_2
static s7_pointer g_hash_table_2(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer ht;
                    ht = s7_make_hash_table(sc, sc->default_hash_table_length);
                    if (cadr(args) != sc->F)
                        hash_table_add(sc, ht, car(args), cadr(args));
                    return(ht);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x270(%rdi), %rsi
callq 0x366fb
movq %rax, %rbx
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
cmpq 0x120(%r14), %rcx
je 0x1030d6
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfefb2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_format_f
static s7_pointer g_format_f(s7_scheme *sc, s7_pointer args)
    {
        /* port == #f, there are other args */
        s7_pointer str;
        sc->format_column = 0;
        str = cadr(args);
        if (!is_string(str))
            return(method_or_bust(sc, str, sc->format_symbol, args, T_STRING, 2));
        return(format_to_port_1(sc, sc->F, string_value(str), cddr(args), NULL, true, true, string_length(str), str));
    }

// Assembly:
movl $0x0, 0x238(%rdi)
movq 0x10(%rsi), %r8
movq 0x8(%r8), %rax
cmpb $0x13, (%rax)
jne 0x103315
pushq %rax
movq 0x120(%rdi), %rsi
movq 0x10(%rax), %rdx
movq 0x10(%r8), %rcx
subq $0x8, %rsp
xorl %r8d, %r8d
movl $0x1, %r9d
pushq %rax
pushq 0x8(%rax)
pushq $0x1
callq 0x969ef
addq $0x20, %rsp
popq %rcx
retq
movq %rsi, %rcx
movq 0xf20(%rdi), %rdx
movq %rax, %rsi
movl $0x13, %r8d
movl $0x2, %r9d
jmp 0xe42d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_format_allg_no_column
static s7_pointer g_format_allg_no_column(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer pt, str;
                    pt = car(args);
                    if (is_null(pt))
                    {
                        pt = sc->output_port;
                        if (pt == sc->F)
                            return(sc->F);
                    }

                    if (!((s7_is_boolean(pt)) ||
                                ((is_output_port(pt)) &&             /* (current-output-port) or call-with-open-file arg, etc */
                                 (!port_is_closed(pt)))))
                        return(method_or_bust_with_type(sc, pt, sc->format_symbol, args, a_format_port_string, 1));

                    str = cadr(args);
                    sc->format_column = 0;
                    return(format_to_port_1(sc, (pt == sc->T) ? sc->output_port : pt,
                                string_value(str), cddr(args), NULL,
                                !is_output_port(pt),   /* i.e. is boolean port so we're returning a string */
                                false,                 /* we checked in advance that it is not columnized */
                                string_length(str),
                                str));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpq 0x110(%rdi), %rsi
jne 0x10335a
movq 0x120(%rdi), %rax
movq 0x188(%rdi), %rsi
cmpq %rax, %rsi
je 0x1033e2
movzbl (%rsi), %eax
cmpl $0x7, %eax
je 0x10338a
cmpl $0x22, %eax
jne 0x103371
movq 0x8(%rsi), %rax
cmpb $0x1, 0x2(%rax)
jne 0x10338a
movq 0xf20(%rdi), %rdx
movq 0x522a9(%rip), %r8      # 0x155628
movl $0x1, %r9d
jmp 0xe659
movq 0x10(%rcx), %rax
movq 0x8(%rax), %r10
movl $0x0, 0x238(%rdi)
movq %rsi, %rax
cmpq 0x118(%rdi), %rsi
jne 0x1033af
movq 0x188(%rdi), %rax
pushq %rax
movq 0x10(%r10), %rdx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
xorl %r9d, %r9d
cmpb $0x22, (%rsi)
setne %r9b
subq $0x8, %rsp
movq %rax, %rsi
xorl %r8d, %r8d
pushq %r10
pushq 0x8(%r10)
pushq $0x0
callq 0x969ef
addq $0x20, %rsp
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_format_just_control_string
static s7_pointer g_format_just_control_string(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer pt, str;
                    pt = car(args);
                    str = cadr(args);

                    if (pt == sc->F)
                        return(str);

                    if (is_null(pt))
                    {
                        pt = sc->output_port;
                        if (pt == sc->F)
                            return(sc->F);
                    }
                    if (pt == sc->T)
                    {
                        if ((sc->output_port != sc->F) && (string_length(str) != 0))
                            port_write_string(sc->output_port)(sc, string_value(str), string_length(str), sc->output_port);
                        return(str);
                    }

                    if ((!is_output_port(pt)) ||
                            (port_is_closed(pt)))
                        return(method_or_bust_with_type(sc, pt, sc->format_symbol, args, a_format_port_string, 1));

                    if (string_length(str) == 0)
                    {
                        if (!is_output_port(pt))
                            return(make_empty_string(sc, 0, 0));
                        return(sc->F);
                    }

                    port_write_string(pt)(sc, string_value(str), string_length(str), pt);
                    return(sc->F);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
movq 0x120(%rdi), %rax
cmpq %rax, %rcx
je 0x103486
movq %rsi, %r9
movq %rdi, %rbx
cmpq 0x110(%rdi), %rcx
jne 0x10341e
movq 0x188(%rbx), %rcx
cmpq %rax, %rcx
je 0x103489
cmpq 0x118(%rbx), %rcx
je 0x10345f
cmpb $0x22, (%rcx)
jne 0x103436
movq 0x8(%rcx), %rsi
cmpb $0x1, 0x2(%rsi)
jne 0x103491
movq 0xf20(%rbx), %rdx
movq 0x521e4(%rip), %r8      # 0x155628
movq %rbx, %rdi
movq %rcx, %rsi
movq %r9, %rcx
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe659
movq 0x188(%rbx), %rcx
cmpq %rax, %rcx
je 0x103486
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x103486
movq 0x8(%rcx), %rax
movq 0x48(%rax), %rax
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x103489
movq 0x48(%rsi), %rax
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x120(%rbx), %rax
jmp 0x103489
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_format_as_objstr
static s7_pointer g_format_as_objstr(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer func, obj;

                    obj = caddr(args);
                    if ((!has_active_methods(sc, obj)) ||
                            ((func = find_method(sc, find_let(sc, obj), sc->format_symbol)) == sc->undefined))
                        return(s7_object_to_string(sc, obj, false));

                    return(s7_apply_function(sc, func, list_3(sc, sc->F, cadr(args), obj)));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r13
movq 0x10(%r13), %rax
movq 0x8(%rax), %r14
testb $0x40, 0x3(%r14)
je 0x1035bb
cmpb $0x1, 0x24c(%rbx)
jne 0x1035bb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a63
movq 0xf20(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x89ff
cmpq 0x128(%rbx), %rax
je 0x1035bb
movq %rax, %r15
movq 0x120(%rbx), %r12
movq 0x8(%r13), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x103541
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 %r14, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%rbx), %rdx
leaq -0x8(%rdx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rdx), %rsi
movq %rcx, (%rsi)
movq %r13, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rax), %rdx
movq %rcx, (%rdx)
movq %r12, 0x8(%rdx)
movq %rsi, 0x10(%rdx)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaee6
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37a4c
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: member_chooser
static s7_pointer member_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if (!ops) return(f);
                    if ((args == 3) &&
                            (is_normal_symbol(cadddr(expr))) &&
                            (cadddr(expr) == sc->is_eq_symbol))
                        return(memq_chooser(sc, f, 2, expr, ops));
                    return(f);
                }

// Assembly:
xorb $0x1, %r8b
cmpl $0x3, %edx
setne %al
orb %r8b, %al
jne 0x1037b4
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0x1037b4
testb $-0x80, 0x6(%rax)
jne 0x1037b4
cmpq 0x1068(%rdi), %rax
je 0x1037b8
movq %rsi, %rax
retq
xorl %r8d, %r8d
jmp 0x1037bd
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: memq_chooser
static s7_pointer memq_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if ((is_proper_quote(sc, caddr(expr))) &&
                            (is_pair(cadr(caddr(expr)))))
                    {
                        s7_int len;
                        len = s7_list_length(sc, cadr(caddr(expr)));
                        if (len > 0)
                        {
                            if (len == 2)
                                return(sc->memq_2);
                            if ((len % 4) == 0)
                                return(sc->memq_4);
                            if ((len % 3) == 0)
                                return(sc->memq_3);
                            return(sc->memq_any);
                        }
                    }
                    return(f);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x103859
movq %rdi, %rbx
movq 0x8(%rax), %rcx
cmpq 0x17b0(%rdi), %rcx
jne 0x103859
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x103859
movq 0x10(%rax), %rcx
cmpq 0x110(%rbx), %rcx
jne 0x103859
movq 0x8(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0x103859
movq %rbx, %rdi
callq 0x39d0d
testq %rax, %rax
jle 0x103859
movl $0x1bd0, %ecx           # imm = 0x1BD0
cmpq $0x2, %rax
je 0x103855
testb $0x3, %al
je 0x103850
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
xorl %ecx, %ecx
cmpq %rdx, %rax
seta %cl
shll $0x4, %ecx
addq $0x1bd8, %rcx           # imm = 0x1BD8
jmp 0x103855
movl $0x1be0, %ecx           # imm = 0x1BE0
movq (%rbx,%rcx), %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: g_memq_3
static s7_pointer g_memq_3(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer x, obj;
                    x = cadr(args);
                    obj = car(args);
                    while (true)
                    {
                        if (obj == car(x)) return(x);
                        x = cdr(x);
                        if (obj == car(x)) return(x);
                        x = cdr(x);
                        if (obj == car(x)) return(x);
                        x = cdr(x);
                        if (!is_pair(x)) return(sc->F);
                    }
                    return(sc->F);
                }

// Assembly:
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x10389a
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x10389a
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x10389a
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x103870
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_memq_4
static s7_pointer g_memq_4(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer x, obj;
                    x = cadr(args);
                    obj = car(args);
                    while (true)
                    {
                        LOOP_4(if (obj == car(x)) return(x); x = cdr(x));
                        if (!is_pair(x)) return(sc->F);
                    }
                    return(sc->F);
                }

// Assembly:
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x1038db
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x1038db
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x1038db
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x1038db
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x1038a7
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: tree_set_memq_chooser
static s7_pointer tree_set_memq_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
    {
        if ((is_proper_quote(sc, cadr(expr))) &&   /* not (tree-set-memq (quote) ... */
            (is_pair(cadadr(expr))))
                {
                s7_pointer p;
                for (p = cadadr(expr); is_pair(p); p = cdr(p))
                if (!is_symbol(car(p)))
                return(f);
                return(sc->tree_set_memq_syms); /* this is tree_set_memq_1 */
                }
                return(f);
                }

// Assembly:
movq %rsi, %rax
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x103949
movq 0x8(%rcx), %rdx
cmpq 0x17b0(%rdi), %rdx
je 0x10394a
retq
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x103949
movq 0x10(%rcx), %rdx
cmpq 0x110(%rdi), %rdx
jne 0x103949
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x103949
movq 0x8(%rcx), %rdx
cmpb $0xa, (%rdx)
jne 0x103949
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0x103969
movq 0x1bf0(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_read_line_uncopied
static s7_pointer g_read_line_uncopied(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer port;
        bool with_eol = false;
        port = car(args);
        if (!is_input_port(port))
            return(g_read_line(sc, args));
        if (is_not_null(cdr(args)))
            with_eol = (cadr(args) != sc->F);
        return(port_read_line(port)(sc, port, with_eol, false));
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
cmpb $0x23, (%rsi)
jne 0x1039ac
movq 0x10(%rax), %rax
cmpq 0x110(%rdi), %rax
je 0x1039b4
movq 0x8(%rax), %rax
cmpq 0x120(%rdi), %rax
setne %al
jmp 0x1039b6
movq %rax, %rsi
jmp 0x637df
xorl %eax, %eax
movq 0x8(%rsi), %rcx
movq 0x48(%rcx), %rcx
movq 0x38(%rcx), %r8
movzbl %al, %edx
xorl %ecx, %ecx
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: inlet_chooser
static s7_pointer inlet_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
    {
        if (!ops) return(f);
        if ((args > 0) &&
                ((args % 2) == 0))
        {
            s7_pointer p;
            for (p = cdr(expr); is_pair(p); p = cddr(p))
            {
                s7_pointer sym;
                if (!is_proper_quote(sc, car(p)))             /* 'abs etc, but tricky: ':abs */
                    return(f);
                sym = cadar(p);
                if ((!is_symbol(sym)) ||
                        (is_possibly_constant(sym)) ||            /* define-constant etc */
                        (is_syntactic_symbol(sym))  ||            /* (inlet 'if 3) */
                        ((is_slot(global_slot(sym))) &&
                         (is_syntactic(slot_value(global_slot(sym))))) ||
                        (sym == sc->let_ref_fallback_symbol) ||
                        (sym == sc->let_set_fallback_symbol))
                    return(f);
            }
            return(sc->simple_inlet);
        }
        return(f);
    }

// Assembly:
movq %rsi, %rax
testl %r8d, %r8d
je 0x103a72
testl %edx, %edx
setle %sil
orb %sil, %dl
testb $0x1, %dl
jne 0x103a72
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x103a6b
movq 0x8(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0x103a72
movq 0x8(%rdx), %rsi
cmpq 0x17b0(%rdi), %rsi
jne 0x103a72
movq 0x10(%rdx), %rdx
cmpb $0x1, (%rdx)
jne 0x103a72
movq 0x10(%rdx), %rsi
cmpq 0x110(%rdi), %rsi
jne 0x103a72
movq 0x8(%rdx), %rdx
cmpb $0xa, (%rdx)
jne 0x103a72
testb $0x1, 0x6(%rdx)
jne 0x103a72
cmpw $0x20a, (%rdx)          # imm = 0x20A
je 0x103a72
movq 0x10(%rdx), %rsi
cmpb $0x20, (%rsi)
jne 0x103a53
movq 0x10(%rsi), %rsi
testb $0x2, 0x1(%rsi)
jne 0x103a72
cmpq 0x1228(%rdi), %rdx
je 0x103a72
cmpq 0x1238(%rdi), %rdx
je 0x103a72
movq 0x10(%rcx), %rcx
jmp 0x1039f5
movq 0x1c00(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: let_ref_chooser
static s7_pointer let_ref_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
    {
        if ((!ops) || (!is_global(sc->let_ref_symbol))) return(f);

        if (optimize_op(expr) == HOP_SAFE_C_opSq_C)
        {
            s7_pointer arg1, arg2;
            arg1 = cadr(expr);
            arg2 = caddr(expr);
            if ((car(arg1) == sc->cdr_symbol) &&
                    (is_quoted_symbol(arg2)) &&
                    (!is_possibly_constant(cadr(arg2))))
            {
                set_opt3_sym(cdr(expr), cadr(arg2));
                return(sc->lint_let_ref);
            }
        }
        return(f);
    }

// Assembly:
movq %rsi, %rax
testl %r8d, %r8d
je 0x103c68
movq 0x1230(%rdi), %rdx
testb $0x1, 0x2(%rdx)
je 0x103c68
cmpw $0x33, 0x4(%rcx)
jne 0x103c68
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rsi
movq 0x8(%rsi), %rsi
cmpq 0xda0(%rdi), %rsi
je 0x103c69
retq
movq 0x10(%rdx), %rsi
movq 0x8(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0x103c68
movq 0x8(%rsi), %r8
cmpq 0x17b0(%rdi), %r8
jne 0x103c68
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x103c68
testb $0x1, 0x6(%rsi)
jne 0x103c68
movq %rsi, 0x28(%rdx)
movq 0x10(%rcx), %rax
andq $-0x40001, (%rax)       # imm = 0xFFFBFFFF
movq 0x1c08(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: let_set_chooser
static s7_pointer let_set_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
    {
        if ((!ops) || (!is_global(sc->let_set_symbol))) return(f);
        if (optimize_op(expr) == HOP_SAFE_C_opSq_CS)
        {
            s7_pointer arg1, arg2, arg3;
            arg1 = cadr(expr);
            arg2 = caddr(expr);
            arg3 = cadddr(expr);
            if ((car(arg1) == sc->cdr_symbol) &&
                    (car(arg2) == sc->quote_symbol) &&
                    (is_symbol(cadr(arg2))) &&
                    (!is_possibly_constant(cadr(arg2))) &&
                    (!is_possibly_constant(arg3)))
                return(sc->lint_let_set);
        }
        return(f);
    }

// Assembly:
movq %rsi, %rax
testl %r8d, %r8d
je 0x103cde
movq 0x1240(%rdi), %rdx
testb $0x1, 0x2(%rdx)
je 0x103cde
cmpw $0x6b, 0x4(%rcx)
jne 0x103cde
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq 0x8(%rdx), %rdx
cmpq 0xda0(%rdi), %rdx
je 0x103cdf
retq
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq 0x8(%rdx), %rsi
cmpq 0x17b0(%rdi), %rsi
jne 0x103cde
movq 0x10(%rdx), %rdx
movq 0x8(%rdx), %rdx
cmpb $0xa, (%rdx)
jne 0x103cde
testb $0x1, 0x6(%rdx)
jne 0x103cde
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
testb $0x1, 0x6(%rcx)
jne 0x103cde
movq 0x1c10(%rdi), %rax
retq