LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rbx
movzbl (%rbx), %ecx
leaq 0x4adf7(%rip), %rdx     # 0x1199b0
cmpb $0x0, (%rcx,%rdx)
je 0xcebd9
movq 0x8(%rsi), %r14
testb $0x1, 0x3(%r14)
jne 0xcec06
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0xcec40
movq 0x8(%rax), %r15
jmp 0xcec43
movq 0xef8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x46d7d(%rip), %rdx     # 0x115968
movq 0x140(%rdi), %r8
movq 0x4aecf(%rip), %r9      # 0x119ac8
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x9bbb
movq 0x4ad5b(%rip), %rax     # 0x119968
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), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x972b
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0xc42a
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_O2/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:
movq %rsi, %r10
movq 0x8(%rsi), %rsi
cmpb $0x16, (%rsi)
jne 0xcee96
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xcee56
cmpq $0x1, 0x10(%rax)
jne 0xceec1
movq 0x10(%r10), %rdx
movq 0x8(%rdx), %rax
cmpb $0xb, (%rax)
jne 0xceea7
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0xceed3
cmpq 0x8(%rsi), %rcx
jge 0xceed3
movq 0x10(%rdx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0xceefe
testb $0x1, 0x3(%rsi)
jne 0xcef0d
movq 0x8(%rax), %rdx
movq 0x10(%rsi), %rsi
movq %rdx, (%rsi,%rcx,8)
retq
movq 0xfb0(%rdi), %rdx
pushq $0x16
popq %r8
pushq $0x1
popq %r9
jmp 0xceeb9
movq 0xfb0(%rdi), %rdx
pushq $0xb
popq %r8
pushq $0x2
popq %r9
movq %rax, %rsi
movq %r10, %rcx
jmp 0xcd70
movq 0xfb0(%rdi), %rdx
pushq $0x16
popq %rcx
movq %r10, %rsi
jmp 0xcb853
testq %rcx, %rcx
movq 0xfb0(%rdi), %rcx
movq 0x8(%rcx), %rsi
leaq 0x4ab60(%rip), %rcx     # 0x119a48
leaq 0x4ab51(%rip), %rdx     # 0x119a40
cmovsq %rcx, %rdx
movq (%rdx), %rcx
movq %rax, %rdx
jmp 0x35b47
movq 0xfb0(%rdi), %rdx
pushq $0xb
popq %r8
pushq $0x3
jmp 0xceeb4
movq 0x4aa54(%rip), %rax     # 0x119968
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), %rsi
jmp 0x972b
// File: /workspace/github_c_makefile_star2_O2/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, %rax
movq 0x8(%rsi), %rsi
cmpb $0x18, (%rsi)
jne 0xcefb1
movq 0x18(%rsi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0xcef80
cmpq $0x1, 0x10(%rcx)
jne 0xcefdc
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %r10
cmpb $0xb, (%r10)
jne 0xcefc2
movq 0x8(%r10), %rax
testq %rax, %rax
js 0xcefee
cmpq 0x8(%rsi), %rax
jge 0xcefee
movq 0x10(%rsi), %rcx
movzbl (%rcx,%rax), %eax
leaq 0x469a4(%rip), %rcx     # 0x115950
movq (%rcx,%rax,8), %rax
retq
movq 0xc30(%rdi), %rdx
pushq $0x18
popq %r8
pushq $0x1
popq %r9
jmp 0xcefd4
movq 0xc30(%rdi), %rdx
pushq $0xb
popq %r8
pushq $0x2
popq %r9
movq %r10, %rsi
movq %rax, %rcx
jmp 0xcd70
movq 0xc30(%rdi), %rdx
pushq $0x18
popq %rcx
movq %rax, %rsi
jmp 0xa941e
testq %rax, %rax
movq 0xc30(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0x4aa45(%rip), %rax     # 0x119a48
leaq 0x4aa36(%rip), %rcx     # 0x119a40
cmovsq %rax, %rcx
movq (%rcx), %rcx
movq %r10, %rdx
jmp 0x35b47
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rax
movq 0x8(%rsi), %rsi
cmpb $0x18, (%rsi)
jne 0xcf0b5
movq 0x18(%rsi), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0xcf0cc
cmpq $0x2, 0x10(%rcx)
jne 0xcf0cc
movq 0x10(%rax), %r8
movq 0x8(%r8), %r10
cmpb $0xb, (%r10)
jne 0xcf0de
movq 0x8(%r10), %rdx
testq %rdx, %rdx
js 0xcf0f2
movq (%rcx), %r9
cmpq (%r9), %rdx
jge 0xcf0f2
movq 0x10(%r8), %r8
movq 0x8(%r8), %r10
cmpb $0xb, (%r10)
jne 0xcf11d
movq 0x8(%r10), %rax
testq %rax, %rax
js 0xcf12c
cmpq 0x8(%r9), %rax
jge 0xcf12c
movq 0x18(%rcx), %rcx
imulq (%rcx), %rdx
addq 0x10(%rsi), %rdx
movzbl (%rax,%rdx), %eax
leaq 0x468a0(%rip), %rcx     # 0x115950
movq (%rcx,%rax,8), %rax
retq
movq 0xc30(%rdi), %rdx
pushq $0x18
popq %r8
pushq $0x1
popq %r9
movq %rax, %rcx
jmp 0xcd70
movq 0xc30(%rdi), %rdx
pushq $0x18
popq %rcx
movq %rax, %rsi
jmp 0xa941e
movq 0xc30(%rdi), %rdx
pushq $0xb
popq %r8
pushq $0x2
popq %r9
movq %r10, %rsi
jmp 0xcf0c4
testq %rdx, %rdx
movq 0xc30(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0x4a941(%rip), %rax     # 0x119a48
leaq 0x4a932(%rip), %rcx     # 0x119a40
cmovsq %rax, %rcx
movq (%rcx), %rcx
movq %r10, %rdx
jmp 0x35b47
movq 0xc30(%rdi), %rdx
pushq $0xb
popq %r8
pushq $0x3
jmp 0xcf0eb
testq %rax, %rax
jmp 0xcf0f5
// File: /workspace/github_c_makefile_star2_O2/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 0xcf31e
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpb $0xb, (%rcx)
jne 0xcf31e
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
js 0xcf31e
cmpq 0x2b0(%rdi), %rcx
jge 0xcf31e
movq 0x1b98(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: g_list_set_i
static s7_pointer g_list_set_i(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer p, lst, val;
                    s7_int i, index;
                    lst = car(args);
                    if (!is_mutable_pair(lst))
                        return(mutable_method_or_bust(sc, lst, sc->list_set_symbol, args, T_PAIR, 1));

                    index = s7_integer(cadr(args));
                    if ((index < 0) || (index > sc->max_list_length))
                        return(out_of_range(sc, sc->list_set_symbol, small_int(2), wrap_integer1(sc, index), (index < 0) ? its_negative_string : its_too_large_string));

                    for (i = 0, p = lst; (i < index) && is_pair(p); i++, p = cdr(p)) {}
                    if (!is_pair(p))
                    {
                        if (is_null(p))
                            return(out_of_range(sc, sc->list_set_symbol, small_int(2), wrap_integer1(sc, index), its_too_large_string));
                        return(wrong_type_argument_with_type(sc, sc->list_set_symbol, 1, lst, a_proper_list_string));
                    }

                    val = caddr(args);
                    set_car(p, val);
                    return(val);
                }

// Assembly:
movq %rsi, %rax
movq 0x8(%rsi), %rcx
movl $0x10000ff, %edx        # imm = 0x10000FF
andl (%rcx), %edx
cmpl $0x1, %edx
jne 0xcf34d
movq 0x10(%rax), %rdx
movq 0x8(%rdx), %rax
cmpb $0xb, (%rax)
jne 0xcf363
movq 0x8(%rax), %rax
testq %rax, %rax
jns 0xcf365
movb $0x1, %r8b
jmp 0xcf371
movq 0x1260(%rdi), %rdx
pushq $0x1
popq %r8
movq %rcx, %rsi
movq %rax, %rcx
jmp 0xb7b5b
xorl %eax, %eax
cmpq 0x2b0(%rdi), %rax
jle 0xcf3b2
xorl %r8d, %r8d
movq 0x1260(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x465dd(%rip), %rdx     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
leaq 0x4a6ac(%rip), %rax     # 0x119a48
leaq 0x4a69d(%rip), %r9      # 0x119a40
testb %r8b, %r8b
cmovneq %rax, %r9
movq (%r9), %r8
jmp 0xcb8f
movq %rax, %rsi
movq %rcx, %r8
movb (%r8), %r9b
subq $0x1, %rsi
jb 0xcf3cd
cmpb $0x1, %r9b
jne 0xcf3e0
movq 0x10(%r8), %r8
jmp 0xcf3b8
cmpb $0x1, %r9b
jne 0xcf3e0
movq 0x10(%rdx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%r8)
retq
movq 0x1260(%rdi), %rdx
movq 0x8(%rdx), %rsi
cmpq 0x110(%rdi), %r8
je 0xcf40e
movq 0x4655d(%rip), %rdx     # 0x115958
movq 0x140(%rdi), %r8
movq 0x5280f(%rip), %r9      # 0x121c18
jmp 0x9bbb
movq 0x4654b(%rip), %rdx     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
movq 0x4a612(%rip), %r8      # 0x119a40
jmp 0xcb8f
// File: /workspace/github_c_makefile_star2_O2/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 0x2a5ea
movq %rax, %rbx
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
cmpq 0x120(%r14), %rcx
je 0xcf5b6
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcbaa5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
andl $0x0, 0x238(%rdi)
movq 0x10(%rsi), %r8
movq 0x8(%r8), %rax
cmpb $0x13, (%rax)
jne 0xcf7da
pushq %rax
movq 0x120(%rdi), %rsi
movq 0x10(%rax), %rdx
movq 0x10(%r8), %rcx
subq $0x8, %rsp
pushq $0x1
popq %r9
xorl %r8d, %r8d
pushq %rax
pushq 0x8(%rax)
pushq $0x1
callq 0x78627
addq $0x20, %rsp
popq %rcx
retq
movq %rsi, %rcx
movq 0xf20(%rdi), %rdx
pushq $0x13
popq %r8
pushq $0x2
popq %r9
movq %rax, %rsi
jmp 0xcd70
// File: /workspace/github_c_makefile_star2_O2/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 0xcf81b
movq 0x120(%rdi), %rax
movq 0x188(%rdi), %rsi
cmpq %rax, %rsi
je 0xcf8a6
movzbl (%rsi), %eax
cmpl $0x7, %eax
je 0xcf849
cmpl $0x22, %eax
jne 0xcf832
movq 0x8(%rsi), %rax
cmpb $0x1, 0x2(%rax)
jne 0xcf849
movq 0xf20(%rdi), %rdx
movq 0x54de8(%rip), %r8      # 0x124628
pushq $0x1
popq %r9
jmp 0xcf9a
movq 0x10(%rcx), %rax
movq 0x8(%rax), %r8
andl $0x0, 0x238(%rdi)
movq %rsi, %rax
cmpq 0x118(%rdi), %rsi
jne 0xcf86b
movq 0x188(%rdi), %rax
subq $0x18, %rsp
movq 0x8(%r8), %r10
movq 0x10(%r8), %rdx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
xorl %r9d, %r9d
cmpb $0x22, (%rsi)
setne %r9b
andl $0x0, (%rsp)
movq %r8, 0x10(%rsp)
movq %r10, 0x8(%rsp)
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x78627
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcf948
movq %rsi, %r10
movq %rdi, %rbx
cmpq 0x110(%rdi), %rcx
jne 0xcf8e2
movq 0x188(%rbx), %rcx
cmpq %rax, %rcx
je 0xcf94b
cmpq 0x118(%rbx), %rcx
je 0xcf921
cmpb $0x22, (%rcx)
jne 0xcf8fa
movq 0x8(%rcx), %rsi
cmpb $0x1, 0x2(%rsi)
jne 0xcf953
movq 0xf20(%rbx), %rdx
movq 0x54d20(%rip), %r8      # 0x124628
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %rcx, %rsi
movq %r10, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcf9a
movq 0x188(%rbx), %rcx
cmpq %rax, %rcx
je 0xcf948
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0xcf948
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 0xcf94b
movq 0x48(%rsi), %rax
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x120(%rbx), %rax
jmp 0xcf94b
// File: /workspace/github_c_makefile_star2_O2/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 0xcfa7d
cmpb $0x1, 0x24c(%rbx)
jne 0xcfa7d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq 0xf20(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x888f
cmpq 0x128(%rbx), %rax
je 0xcfa7d
movq %rax, %r15
movq 0x120(%rbx), %r12
movq 0x8(%r13), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xcfa03
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 %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 0xa34c
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 0x2b7ea
// File: /workspace/github_c_makefile_star2_O2/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 0xcfc76
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0xcfc76
testb $-0x80, 0x6(%rax)
jne 0xcfc76
cmpq 0x1068(%rdi), %rax
je 0xcfc7a
movq %rsi, %rax
retq
xorl %r8d, %r8d
jmp 0xcfc7f
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
movq %r15, %rsi
callq 0x86533
testb %al, %al
je 0xcfcf0
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0xcfcf0
movq %rbx, %rdi
callq 0x2dada
testq %rax, %rax
jle 0xcfcf0
movl $0x1bd0, %ecx           # imm = 0x1BD0
cmpq $0x2, %rax
je 0xcfcec
testb $0x3, %al
je 0xcfce7
pushq $0x3
popq %rcx
xorl %edx, %edx
divq %rcx
xorl %ecx, %ecx
testq %rdx, %rdx
setne %cl
shll $0x4, %ecx
addq $0x1bd8, %rcx           # imm = 0x1BD8
jmp 0xcfcec
movl $0x1be0, %ecx           # imm = 0x1BE0
movq (%rbx,%rcx), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcfd2f
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0xcfd2f
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0xcfd2f
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xcfd05
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcfd70
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0xcfd70
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0xcfd70
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0xcfd70
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0xcfd3c
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rcx), %rax
movq 0x8(%rax), %r15
movq %r15, %rsi
callq 0x86533
testb %al, %al
je 0xcfe0c
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0xcfe0c
movb $0x1, %cl
cmpb $0x1, %cl
jne 0xcfe05
movq 0x8(%rax), %rcx
cmpb $0xa, (%rcx)
jne 0xcfe0c
movq 0x10(%rax), %rax
movb (%rax), %cl
jmp 0xcfdef
movq 0x1bf0(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcfe3e
movq 0x10(%rax), %rax
cmpq 0x110(%rdi), %rax
je 0xcfe46
movq 0x8(%rax), %rax
cmpq 0x120(%rdi), %rax
setne %al
jmp 0xcfe48
movq %rax, %rsi
jmp 0x4f732
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_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %r8d, %r8d
je 0xcfef8
testl %edx, %edx
setle %al
orb %al, %dl
testb $0x1, %dl
jne 0xcfef8
movq %rdi, %r14
movq 0x10(%rcx), %r12
cmpb $0x1, (%r12)
jne 0xcfef1
movq 0x8(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x86533
testb %al, %al
je 0xcfef8
movq 0x10(%r15), %rax
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0xcfef8
testb $0x1, 0x6(%rax)
jne 0xcfef8
cmpw $0x20a, (%rax)          # imm = 0x20A
je 0xcfef8
movq 0x10(%rax), %rcx
cmpb $0x20, (%rcx)
jne 0xcfed8
movq 0x10(%rcx), %rcx
testb $0x2, 0x1(%rcx)
jne 0xcfef8
cmpq 0x1228(%r14), %rax
je 0xcfef8
cmpq 0x1238(%r14), %rax
je 0xcfef8
movq 0x10(%r12), %rcx
jmp 0xcfe8c
movq 0x1c00(%r14), %rbx
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: g_simple_inlet
static s7_pointer g_simple_inlet(s7_scheme *sc, s7_pointer args)
    {
        /* here all args are paired with normal symbol/value, no fallbacks, no immutable symbols etc */
        s7_pointer new_e, x;
        int64_t id;
        new_e = new_frame_in_env(sc, sc->nil);
        sc->temp3 = new_e;
        id = let_id(new_e);
        for (x = args; is_pair(x); x = cddr(x))
        {
            s7_pointer symbol, slot;
            symbol = car(x);
            if (is_keyword(symbol))                 /* (inlet ':allow-other-keys 3) */
                symbol = keyword_symbol(symbol);
            if (is_constant_symbol(sc, symbol))     /* (inlet 'pi 1) */
                return(wrong_type_argument_with_type(sc, sc->inlet_symbol, 1, symbol, a_non_constant_symbol_string));
            new_cell_no_check(sc, slot, T_SLOT);
            slot_set_symbol(slot, symbol);
            slot_set_value(slot, cadr(x));
            slot_set_next(slot, let_slots(new_e));
            let_set_slots(new_e, slot);
            set_local(symbol);
            symbol_set_local(symbol, id, slot);
        }
        sc->temp3 = sc->nil;
        return(new_e);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x110(%rdi), %rsi
callq 0x72a1d
movq %rax, %r15
movq %rax, 0x508(%rbx)
movq 0x18(%rax), %r13
movq $-0x112201, %rbp        # imm = 0xFFEEDDFF
cmpb $0x1, (%r14)
jne 0xcffd6
movq 0x8(%r14), %r12
testb $-0x80, 0x6(%r12)
je 0xcff5c
movq 0x8(%r12), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x72bfa
testb %al, %al
jne 0xcfff6
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x20, (%rax)
movq %r12, 0x8(%rax)
movq 0x10(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x8(%r15)
movq (%r12), %rcx
andq %rbp, %rcx
orq $0x100000, %rcx         # imm = 0x100000
movq %rcx, (%r12)
movq %rax, 0x18(%r12)
movq %r13, 0x20(%r12)
incl 0x28(%r12)
movq 0x10(%r14), %rax
movq 0x10(%rax), %r14
jmp 0xcff39
movq 0x110(%rbx), %rax
movq %rax, 0x508(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xfa0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x45950(%rip), %rdx     # 0x115958
movq 0x140(%rbx), %r8
movq 0x4cea2(%rip), %r9      # 0x11ceb8
movq %rbx, %rdi
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9bbb
// File: /workspace/github_c_makefile_star2_O2/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 0xd0060
movq 0x1230(%rdi), %rdx
testb $0x1, 0x2(%rdx)
je 0xd0060
cmpw $0x33, 0x4(%rcx)
jne 0xd0060
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rsi
movq 0x8(%rsi), %rsi
cmpq 0xda0(%rdi), %rsi
je 0xd0061
retq
movq 0x10(%rdx), %rsi
movq 0x8(%rsi), %rsi
cmpb $0x1, (%rsi)
jne 0xd0060
movq 0x8(%rsi), %r8
cmpq 0x17b0(%rdi), %r8
jne 0xd0060
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0xd0060
testb $0x1, 0x6(%rsi)
jne 0xd0060
movq %rsi, 0x28(%rdx)
movq 0x10(%rcx), %rax
andq $-0x40001, (%rax)       # imm = 0xFFFBFFFF
movq 0x1c08(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd00d6
movq 0x1240(%rdi), %rdx
testb $0x1, 0x2(%rdx)
je 0xd00d6
cmpw $0x6b, 0x4(%rcx)
jne 0xd00d6
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq 0x8(%rdx), %rdx
cmpq 0xda0(%rdi), %rdx
je 0xd00d7
retq
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rdx
movq 0x8(%rdx), %rsi
cmpq 0x17b0(%rdi), %rsi
jne 0xd00d6
movq 0x10(%rdx), %rdx
movq 0x8(%rdx), %rdx
cmpb $0xa, (%rdx)
jne 0xd00d6
testb $0x1, 0x6(%rdx)
jne 0xd00d6
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
testb $0x1, 0x6(%rcx)
jne 0xd00d6
movq 0x1c10(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: chooser_check_arg_types
static s7_pointer chooser_check_arg_types(s7_scheme *sc, s7_pointer arg1, s7_pointer arg2, s7_pointer fallback,
                        s7_pointer f_2_ff, s7_pointer f_2_ii, s7_pointer f_2_if, s7_pointer f_2_fi,
                        s7_pointer f_2_xi, s7_pointer f_2_ix, s7_pointer f_2_fx, s7_pointer f_2_xf)
                {
                    s7_pointer arg1_type, arg2_type;

                    arg1_type = argument_type(sc, arg1);
                    arg2_type = argument_type(sc, arg2);

                    if ((arg1_type) || (arg2_type))
                    {
                        if (arg1_type == sc->is_float_symbol)
                        {
                            if (arg2_type == sc->is_float_symbol)
                                return(f_2_ff);
                            if (arg2_type == sc->is_integer_symbol)
                                return(f_2_fi);
                            return(f_2_fx);
                        }
                        if (arg1_type == sc->is_integer_symbol)
                        {
                            if (arg2_type == sc->is_float_symbol)
                                return(f_2_if);
                            if (arg2_type == sc->is_integer_symbol)
                                return(f_2_ii);
                            return(f_2_ix);
                        }
                        if (arg2_type == sc->is_float_symbol)
                            return(f_2_xf);
                        if (arg2_type == sc->is_integer_symbol)
                            return(f_2_xi);
                    }
                    return(fallback);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %rbp
movq %rdi, %r12
callq 0xd0341
movq %rax, %r13
movq %r12, %rdi
movq %rbp, %rsi
callq 0xd0341
movq %r13, %rcx
orq %rax, %rcx
je 0xd02ea
movq 0x11e0(%r12), %rcx
cmpq %rcx, %r13
je 0xd02ff
movq 0x10d0(%r12), %rdx
cmpq %rdx, %r13
je 0xd0319
cmpq %rcx, %rax
je 0xd032c
cmpq %rdx, %rax
je 0xd0333
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %r13, %rax
je 0xd02ed
cmpq 0x10d0(%r12), %rax
movq 0x48(%rsp), %rbx
cmovneq 0x60(%rsp), %rbx
jmp 0xd02ed
cmpq %rcx, %rax
je 0xd033a
cmpq %r13, %rax
cmovneq 0x58(%rsp), %r14
movq %r14, %rbx
jmp 0xd02ed
movq 0x68(%rsp), %rbx
jmp 0xd02ed
movq 0x50(%rsp), %rbx
jmp 0xd02ed
movq 0x40(%rsp), %rbx
jmp 0xd02ed
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: argument_type
static s7_pointer argument_type(s7_scheme *sc, s7_pointer arg1)
                {
                    if (is_pair(arg1))
                    {
                        if (car(arg1) == sc->quote_symbol)
                            return(s7_type_of(sc, cadr(arg1)));

                        if ((is_h_optimized(arg1)) &&
                                (is_safe_c_op(optimize_op(arg1))) &&
                                (is_c_function(opt1_cfunc(arg1))))
                        {
                            s7_pointer sig;
                            sig = c_function_signature(opt1_cfunc(arg1));
                            if ((sig) &&
                                    (is_pair(sig)) &&
                                    (is_symbol(car(sig))))
                                return(car(sig));
                        }
                    }
                    else
                    {
                        if (!is_symbol(arg1))
                            return(s7_type_of(sc, arg1));
                    }
                    return(NULL);
                }

// Assembly:
movzbl (%rsi), %eax
cmpl $0xa, %eax
je 0xd039f
cmpl $0x1, %eax
jne 0xd03a2
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rdi), %rax
je 0xd03ab
movq %rbx, %rdi
callq 0xb26ed
testb %al, %al
je 0xd039b
movl 0x4(%rbx), %eax
addl $-0x2, %eax
cmpw $0x9b, %ax
ja 0xd039b
movq 0x18(%rbx), %rax
cmpb $0x30, (%rax)
jb 0xd039b
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0xd039b
cmpb $0x1, (%rax)
jne 0xd039b
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
je 0xd03be
xorl %eax, %eax
jmp 0xd03be
xorl %eax, %eax
retq
movq 0x8e8(%rdi,%rax,8), %rax
retq
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
movq 0x8e8(%rdi,%rax,8), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: c_rem_int
static inline s7_int c_rem_int(s7_scheme *sc, s7_int x, s7_int y)
    {
        if (y == 0)
            division_by_zero_error(sc, sc->remainder_symbol, set_elist_2(sc, wrap_integer1(sc, x), wrap_integer2(sc, y)));
        if ((y == 1) || (y == -1))   /* (remainder most-negative-fixnum -1) will segfault with arithmetic exception */
            return(0);
        return(x % y);
    }

// Assembly:
xorl %eax, %eax
cmpq $-0x1, %rdx
je 0xd0545
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq $0x1, %rdx
je 0xd053e
movq %rsi, %r14
testq %rbx, %rbx
jne 0xd0533
movq 0x1470(%rdi), %rsi
movq 0x1f00(%rdi), %rax
movq %r14, 0x8(%rax)
movq 0x1f00(%rdi), %rax
movq 0x1f08(%rdi), %rcx
andq $0x0, 0x8(%rcx)
movq 0x1f08(%rdi), %rcx
movq 0x6e0(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%rdi), %rdx
callq 0xc1ff
movq %r14, %rax
cqto
idivq %rbx
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: lt_out_y
static bool lt_out_y(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, y))
            return(find_and_apply_method(sc, find_let(sc, y), sc->lt_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->lt_symbol, 2, y, T_REAL);
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testb $0x40, 0x3(%rdx)
je 0xd0b16
cmpb $0x1, 0x24c(%rbx)
jne 0xd0b16
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq %rax, %r12
movq 0x12c0(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xd0abc
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 %r14, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x73dc9
cmpq 0x120(%rbx), %rax
setne %al
jmp 0xd0b43
movq 0x12c0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x44e38(%rip), %rdx     # 0x115960
movq 0x140(%rbx), %r8
movq 0x48f92(%rip), %r9      # 0x119ac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x9bbb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: geq_out_y
static bool geq_out_y(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, y))
            return(find_and_apply_method(sc, find_let(sc, y), sc->geq_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->geq_symbol, 2, y, T_REAL);
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testb $0x40, 0x3(%rdx)
je 0xd0c12
cmpb $0x1, 0x24c(%rbx)
jne 0xd0c12
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88f3
movq %rax, %r12
movq 0xf48(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0xd0bb8
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 %r14, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x73dc9
cmpq 0x120(%rbx), %rax
setne %al
jmp 0xd0c3f
movq 0xf48(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x44d3c(%rip), %rdx     # 0x115960
movq 0x140(%rbx), %r8
movq 0x48e96(%rip), %r9      # 0x119ac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x9bbb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: check_char2_args
static inline void check_char2_args(s7_scheme *sc, s7_pointer caller, s7_pointer p1, s7_pointer p2)
    {
        if (!s7_is_character(p1))
            simple_wrong_type_argument(sc, caller, p1, T_CHARACTER);
        if (!s7_is_character(p2))
            simple_wrong_type_argument(sc, caller, p2, T_CHARACTER);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x8, (%rdx)
je 0xd0c7b
movq 0x8(%r15), %rsi
movq 0x140(%r14), %rcx
movq 0x48e2d(%rip), %r8      # 0x119aa0
movq %r14, %rdi
callq 0xd456
cmpb $0x8, (%rbx)
jne 0xd0c86
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r15), %rsi
movq 0x140(%r14), %rcx
movq 0x48e08(%rip), %r8      # 0x119aa0
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: check_string2_args
static inline void check_string2_args(s7_scheme *sc, s7_pointer caller, s7_pointer p1, s7_pointer p2)
    {
        if (!is_string(p1))
            simple_wrong_type_argument(sc, caller, p1, T_STRING);
        if (!s7_is_string(p2))
            simple_wrong_type_argument(sc, caller, p2, T_STRING);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x13, (%rdx)
je 0xd0cd5
movq 0x8(%r15), %rsi
movq 0x140(%r14), %rcx
movq 0x48e2b(%rip), %r8      # 0x119af8
movq %r14, %rdi
callq 0xd456
cmpb $0x13, (%rbx)
jne 0xd0ce0
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r15), %rsi
movq 0x140(%r14), %rcx
movq 0x48e06(%rip), %r8      # 0x119af8
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xd456
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: sl_integer_gt_0
static s7_pointer sl_integer_gt_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_integer(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_INTEGER));
                    if (s7_integer(val) <= 0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be positive", 18)));
                    return(val);
                }

// Assembly:
cmpb $0xb, (%rdx)
jne 0xd0d12
cmpq $0x0, 0x8(%rdx)
jle 0xd0d29
movq %rdx, %rax
retq
movq 0x8(%rsi), %rsi
movq 0x140(%rdi), %rcx
movq 0x48d94(%rip), %r8      # 0x119ab8
jmp 0xd456
movq 0x8(%rsi), %rsi
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r8
movq (%rax,%r8,8), %rcx
leal 0x1(%r8), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x17440(%rip), %rax     # 0xe8193
movq %rax, 0x10(%rcx)
movq $0x12, 0x8(%rcx)
jmp 0x35b47
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: sl_real_geq_0
static s7_pointer sl_real_geq_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_real(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_REAL));
                    if (s7_real(val) < 0.0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be positive", 18)));
                    return(val);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rdx), %eax
leaq 0x48bd4(%rip), %rcx     # 0x1199b0
cmpb $0x0, (%rax,%rcx)
je 0xd0e3a
movq %rbx, %rdi
callq 0xc42a
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd0e5c
movq 0x8(%r15), %rsi
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rdx
movq (%rax,%rdx,8), %rcx
leal 0x1(%rdx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%r14)
leaq 0x17375(%rip), %rax     # 0xe8193
movq %rax, 0x10(%rcx)
movq $0x12, 0x8(%rcx)
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x35b47
movq 0x8(%r15), %rsi
movq 0x140(%r14), %rcx
movq 0x48c7c(%rip), %r8      # 0x119ac8
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xd456
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: sl_integer_geq_0
static s7_pointer sl_integer_geq_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_integer(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_INTEGER));
                    if (s7_integer(val) < 0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be non-negative", 18)));
                    return(val);
                }

// Assembly:
cmpb $0xb, (%rdx)
jne 0xd0e75
cmpq $0x0, 0x8(%rdx)
js 0xd0e8c
movq %rdx, %rax
retq
movq 0x8(%rsi), %rsi
movq 0x140(%rdi), %rcx
movq 0x48c31(%rip), %r8      # 0x119ab8
jmp 0xd456
movq 0x8(%rsi), %rsi
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r8
movq (%rax,%r8,8), %rcx
leal 0x1(%r8), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x17305(%rip), %rax     # 0xe81bb
movq %rax, 0x10(%rcx)
movq $0x12, 0x8(%rcx)
jmp 0x35b47