LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x47832(%rip), %rdx     # 0x152c20
cmpb $0x0, (%rcx,%rdx)
je 0x7fcbd
movq 0x18(%rax), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x7fcbd
cmpq $0x2, 0x10(%rcx)
jne 0x7fcbd
movq 0x10(%rsi), %r8
movq 0x8(%r8), %rdx
cmpb $0xb, (%rdx)
jne 0x7fcbd
movq 0x10(%r8), %r8
movq 0x8(%r8), %r8
cmpb $0xb, (%r8)
jne 0x7fcbd
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0x7fcbd
movq 0x8(%r8), %r8
testq %r8, %r8
js 0x7fcbd
movq (%rcx), %r9
cmpq (%r9), %rdx
jge 0x7fcbd
cmpq 0x8(%r9), %r8
jge 0x10b477
movq 0x18(%rcx), %rcx
imulq (%rcx), %rdx
addq %r8, %rdx
movq 0x20(%rax), %rcx
movq %rax, %rsi
jmpq *%rcx
jmp 0x7fcbd
// File: /workspace/github_c_makefile_star2_O1/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 0x10b759
pushq %r14
pushq %rbx
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rcx
movl $0x1b30, %eax           # imm = 0x1B30
cmpb $0xa, (%rcx)
jne 0x10b752
movq 0x10(%rdx), %rsi
movq 0x8(%rsi), %rdx
cmpb $0x1, (%rdx)
je 0x10b752
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %rsi
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0x10b752
cmpb $0x1, (%rsi)
jne 0x10b752
movq 0xef0(%rdi), %r8
movq 0x8(%rsi), %r9
cmpb $0x1, (%r9)
jne 0x10b749
movq 0x8(%r9), %r10
cmpq %r8, %r10
jne 0x10b727
movq 0x10(%r9), %r11
cmpb $0x1, (%r11)
jne 0x10b727
movq 0x10(%r11), %rbx
cmpb $0x1, (%rbx)
jne 0x10b727
movq 0x10(%rbx), %r14
cmpq 0x110(%rdi), %r14
jne 0x10b727
cmpq %rcx, 0x8(%r11)
jne 0x10b727
cmpq %rdx, 0x8(%rbx)
je 0x10b75a
cmpq %rcx, %r10
jne 0x10b749
movq 0x10(%r9), %r9
cmpb $0x1, (%r9)
jne 0x10b749
movq 0x10(%r9), %r10
cmpq 0x110(%rdi), %r10
jne 0x10b749
cmpq %rdx, 0x8(%r9)
je 0x10b75a
movq 0x10(%rsi), %rsi
cmpb $0x1, (%rsi)
je 0x10b6e8
movq (%rdi,%rax), %rax
popq %rbx
popq %r14
retq
movl $0x1b38, %eax           # imm = 0x1B38
jmp 0x10b752
// File: /workspace/github_c_makefile_star2_O1/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 0x47088(%rip), %rdx     # 0x1529b0
cmpb $0x0, (%rax,%rdx)
je 0x10b948
movq 0x8(%rsi), %r14
testb $0x1, 0x3(%r14)
jne 0x10b975
movq 0x8(%rcx), %rcx
cmpb $0xb, (%rcx)
jne 0x10b9b6
movq 0x8(%rcx), %r15
jmp 0x10b9b9
movq 0xef8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x4300e(%rip), %rdx     # 0x14e968
movq 0x140(%rdi), %r8
movq 0x47160(%rip), %r9      # 0x152ac8
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xb31d
movq 0x46fec(%rip), %rax     # 0x152968
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 0x3b366
jmp 0x10b9e4
xorl %r15d, %r15d
cmpb $0xd, %al
jne 0x10b9c4
movsd 0x8(%rbx), %xmm0
jmp 0x10b9da
movq 0x47065(%rip), %rdi     # 0x152a30
leaq 0x7596(%rip), %rdx      # 0x112f68
movq %rbx, %rsi
callq 0xe212
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_O1/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 0x10bc6b
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x10bc23
cmpq $0x1, 0x10(%rax)
jne 0x10bc9c
movq 0x10(%rcx), %r8
movq 0x8(%r8), %rax
cmpb $0xb, (%rax)
jne 0x10bc80
movq 0x8(%rax), %rdx
testq %rdx, %rdx
js 0x10bcb1
cmpq 0x8(%rsi), %rdx
jge 0x10bcb1
movq 0x10(%r8), %rax
movq 0x8(%rax), %rbx
cmpb $0xb, (%rbx)
jne 0x10bd0e
testb $0x1, 0x3(%rsi)
jne 0x10bd29
movq 0x8(%rbx), %rax
movq 0x10(%rsi), %rcx
movq %rax, (%rcx,%rdx,8)
jmp 0x10bd09
movq 0xfb0(%rdi), %rdx
movl $0x16, %r8d
movl $0x1, %r9d
jmp 0x10bc96
movq 0xfb0(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
popq %rbx
jmp 0xf1ae
movq 0xfb0(%rdi), %rdx
movq %rcx, %rsi
movl $0x16, %ecx
popq %rbx
jmp 0x107e66
testq %rdx, %rdx
movq 0xfb0(%rdi), %rcx
movq 0x8(%rcx), %rcx
leaq 0x46d82(%rip), %rdx     # 0x152a48
leaq 0x46d73(%rip), %rsi     # 0x152a40
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 0x3b366
movq %rbx, %rax
popq %rbx
retq
movq 0xfb0(%rdi), %rdx
movq %rbx, %rsi
movl $0xb, %r8d
movl $0x3, %r9d
jmp 0x10bc96
movq 0x46c38(%rip), %rax     # 0x152968
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 0x10bd01
// File: /workspace/github_c_makefile_star2_O1/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 0x10bdd5
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x10bda0
cmpq $0x1, 0x10(%rax)
jne 0x10be08
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x10bded
pushq %rbx
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0x10be1c
cmpq 0x8(%rsi), %rcx
jge 0x10be1c
movq 0x10(%rsi), %rax
movzbl (%rax,%rcx), %eax
leaq 0x42b84(%rip), %rcx     # 0x14e950
movq (%rcx,%rax,8), %rbx
jmp 0x10be74
movq 0xc30(%rdi), %rdx
movl $0x18, %r8d
movl $0x1, %r9d
jmp 0xf1ae
movq 0xc30(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
jmp 0xf1ae
movq 0xc30(%rdi), %rdx
movq %rcx, %rsi
movl $0x18, %ecx
jmp 0xde964
testq %rcx, %rcx
movq 0xc30(%rdi), %rcx
movq 0x8(%rcx), %rcx
leaq 0x46c17(%rip), %rdx     # 0x152a48
leaq 0x46c08(%rip), %rsi     # 0x152a40
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 0x3b366
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10bf19
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rdx
testq %rdx, %rdx
je 0x10bf32
cmpq $0x2, 0x10(%rdx)
jne 0x10bf32
movq 0x10(%rcx), %r9
movq 0x8(%r9), %rax
cmpb $0xb, (%rax)
jne 0x10bf47
movq 0x8(%rax), %r8
testq %r8, %r8
js 0x10bf5f
movq (%rdx), %r10
cmpq (%r10), %r8
jge 0x10bf5f
movq 0x10(%r9), %rax
movq 0x8(%rax), %rax
cmpb $0xb, (%rax)
jne 0x10bfbc
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0x10bfd7
cmpq 0x8(%r10), %rcx
jge 0x10bfd7
movq 0x18(%rdx), %rax
imulq (%rax), %r8
addq 0x10(%rsi), %r8
movzbl (%rcx,%r8), %eax
leaq 0x42a40(%rip), %rcx     # 0x14e950
movq (%rcx,%rax,8), %rbx
jmp 0x10bfb7
movq 0xc30(%rdi), %rdx
movl $0x18, %r8d
movl $0x1, %r9d
popq %rbx
jmp 0xf1ae
movq 0xc30(%rdi), %rdx
movq %rcx, %rsi
movl $0x18, %ecx
popq %rbx
jmp 0xde964
movq 0xc30(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x2, %r9d
jmp 0x10bf2c
testq %r8, %r8
movq 0xc30(%rdi), %rcx
movq 0x8(%rcx), %rcx
leaq 0x46ad4(%rip), %rdx     # 0x152a48
leaq 0x46ac5(%rip), %rsi     # 0x152a40
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 0x3b366
movq %rbx, %rax
popq %rbx
retq
movq 0xc30(%rdi), %rdx
movq %rax, %rsi
movl $0xb, %r8d
movl $0x3, %r9d
jmp 0x10bf2c
testq %rcx, %rcx
jmp 0x10bf62
// File: /workspace/github_c_makefile_star2_O1/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 0x10c1f6
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpb $0xb, (%rcx)
jne 0x10c1f6
cmpq $0x0, 0x8(%rcx)
js 0x10c1f6
movq 0x8(%rcx), %rcx
cmpq 0x2b0(%rdi), %rcx
jge 0x10c1f6
movq 0x1b98(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rsi, %rax
movq 0x8(%rsi), %rcx
movl $0x10000ff, %edx        # imm = 0x10000FF
andl (%rcx), %edx
cmpl $0x1, %edx
jne 0x10c21e
movq 0x10(%rax), %rdx
movq 0x8(%rdx), %rax
cmpb $0xb, (%rax)
jne 0x10c237
movq 0x8(%rax), %rax
jmp 0x10c239
movq 0x1260(%rdi), %rdx
movq %rcx, %rsi
movq %rax, %rcx
movl $0x1, %r8d
popq %rbx
jmp 0xeff2b
xorl %eax, %eax
testq %rax, %rax
js 0x10c247
cmpq 0x2b0(%rdi), %rax
jle 0x10c2c5
testq %rax, %rax
movq 0x1260(%rdi), %rcx
movq 0x8(%rcx), %rcx
movq 0x42704(%rip), %rdx     # 0x14e960
movq 0x1f00(%rdi), %rsi
movq %rax, 0x8(%rsi)
movq 0x1ee8(%rdi), %rax
leaq 0x467d3(%rip), %rsi     # 0x152a48
leaq 0x467c4(%rip), %r8      # 0x152a40
cmovsq %rsi, %r8
movq 0x1f00(%rdi), %rsi
movq (%r8), %r8
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
popq %rbx
retq
movq %rcx, %r8
testq %rax, %rax
je 0x10c2e2
movq %rax, %rsi
movq %rcx, %r8
cmpb $0x1, (%r8)
jne 0x10c2e2
movq 0x10(%r8), %r8
decq %rsi
jne 0x10c2d3
cmpb $0x1, (%r8)
jne 0x10c2f6
movq 0x10(%rdx), %rax
movq 0x8(%rax), %rbx
movq %rbx, 0x8(%r8)
jmp 0x10c2c0
movq 0x1260(%rdi), %rdx
movq 0x8(%rdx), %rsi
cmpq 0x110(%rdi), %r8
je 0x10c325
movq 0x42647(%rip), %rdx     # 0x14e958
movq 0x140(%rdi), %r8
movq 0x4e8f9(%rip), %r9      # 0x15ac18
popq %rbx
jmp 0xb31d
movq 0x42634(%rip), %rcx     # 0x14e960
movq 0x1f00(%rdi), %rdx
movq %rax, 0x8(%rdx)
movq 0x1ee8(%rdi), %rax
movq 0x1f00(%rdi), %rdx
movq 0x466f4(%rip), %r8      # 0x152a40
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
jmp 0x10c2a2
// File: /workspace/github_c_makefile_star2_O1/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 0x38b06
movq %rax, %rbx
movq 0x10(%r15), %rax
movq 0x8(%rax), %rcx
cmpq 0x120(%r14), %rcx
je 0x10c4ec
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1082a0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10c777
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 0x9d135
addq $0x20, %rsp
popq %rcx
retq
movq %rsi, %rcx
movq 0xf20(%rdi), %rdx
movq %rax, %rsi
movl $0x13, %r8d
movl $0x2, %r9d
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/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 0x10c7bc
movq 0x120(%rdi), %rax
movq 0x188(%rdi), %rsi
cmpq %rax, %rsi
je 0x10c844
movzbl (%rsi), %eax
cmpl $0x7, %eax
je 0x10c7ec
cmpl $0x22, %eax
jne 0x10c7d3
movq 0x8(%rsi), %rax
cmpb $0x1, 0x2(%rax)
jne 0x10c7ec
movq 0xf20(%rdi), %rdx
movq 0x50e47(%rip), %r8      # 0x15d628
movl $0x1, %r9d
jmp 0xf3da
movq 0x10(%rcx), %rax
movq 0x8(%rax), %r10
movl $0x0, 0x238(%rdi)
movq %rsi, %rax
cmpq 0x118(%rdi), %rsi
jne 0x10c811
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 0x9d135
addq $0x20, %rsp
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10c8e8
movq %rsi, %r9
movq %rdi, %rbx
cmpq 0x110(%rdi), %rcx
jne 0x10c880
movq 0x188(%rbx), %rcx
cmpq %rax, %rcx
je 0x10c8eb
cmpq 0x118(%rbx), %rcx
je 0x10c8c1
cmpb $0x22, (%rcx)
jne 0x10c898
movq 0x8(%rcx), %rsi
cmpb $0x1, 0x2(%rsi)
jne 0x10c8f3
movq 0xf20(%rbx), %rdx
movq 0x50d82(%rip), %r8      # 0x15d628
movq %rbx, %rdi
movq %rcx, %rsi
movq %r9, %rcx
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf3da
movq 0x188(%rbx), %rcx
cmpq %rax, %rcx
je 0x10c8e8
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x10c8e8
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 0x10c8eb
movq 0x48(%rsi), %rax
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x120(%rbx), %rax
jmp 0x10c8eb
// File: /workspace/github_c_makefile_star2_O1/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 0x10ca1d
cmpb $0x1, 0x24c(%rbx)
jne 0x10ca1d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq 0xf20(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0x10ca1d
movq %rax, %r15
movq 0x120(%rbx), %r12
movq 0x8(%r13), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x10c99c
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %ecx         # imm = 0x200001
movq %rcx, (%rax)
movq %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 0xbd41
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 0x39f84
// File: /workspace/github_c_makefile_star2_O1/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 0x10cc16
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0x10cc16
testb $-0x80, 0x6(%rax)
jne 0x10cc16
cmpq 0x1068(%rdi), %rax
je 0x10cc1a
movq %rsi, %rax
retq
xorl %r8d, %r8d
jmp 0x10cc1f
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x10ccc6
movq %rdi, %r14
movq 0x8(%rax), %rcx
cmpq 0x17b0(%rdi), %rcx
jne 0x10ccc6
movq 0x10(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x10ccc6
movq 0x10(%rcx), %rcx
cmpq 0x110(%r14), %rcx
jne 0x10ccc6
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0x1, (%rsi)
jne 0x10ccc6
movq %r14, %rdi
callq 0x3c299
testq %rax, %rax
jle 0x10ccb6
movl $0x1bd0, %ecx           # imm = 0x1BD0
cmpq $0x2, %rax
je 0x10ccbd
testb $0x3, %al
je 0x10ccb8
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
movabsq $0x5555555555555555, %rsi # imm = 0x5555555555555555
xorl %ecx, %ecx
cmpq %rsi, %rdx
seta %cl
shll $0x4, %ecx
addq $0x1bd8, %rcx           # imm = 0x1BD8
jmp 0x10ccbd
jmp 0x10ccc1
movl $0x1be0, %ecx           # imm = 0x1BE0
movq (%r14,%rcx), %rcx
testq %rax, %rax
jg 0x10ccc9
movq %rbx, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10cd0a
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x10cd0a
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x10cd0a
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x10cce0
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10cd4b
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x10cd4b
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x10cd4b
movq 0x10(%rax), %rax
cmpq 0x8(%rax), %rcx
je 0x10cd4b
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x10cd17
movq 0x120(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10cdb9
movq 0x8(%rcx), %rdx
cmpq 0x17b0(%rdi), %rdx
je 0x10cdba
retq
movq 0x10(%rcx), %rdx
cmpb $0x1, (%rdx)
jne 0x10cdb9
movq 0x10(%rdx), %rdx
cmpq 0x110(%rdi), %rdx
jne 0x10cdb9
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x10cdb9
cmpb $0x1, (%rcx)
jne 0x10cdf1
movq 0x8(%rcx), %rdx
cmpb $0xa, (%rdx)
jne 0x10cdb9
movq 0x10(%rcx), %rcx
jmp 0x10cddd
movq 0x1bf0(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10ce22
movq 0x10(%rax), %rax
cmpq 0x110(%rdi), %rax
je 0x10ce2a
movq 0x8(%rax), %rax
cmpq 0x120(%rdi), %rax
setne %al
jmp 0x10ce2c
movq %rax, %rsi
jmp 0x68809
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_O1/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 0x10cf14
testl %edx, %edx
setle %sil
orb %sil, %dl
testb $0x1, %dl
jne 0x10cf14
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
jne 0x10cf0d
movq 0x8(%rcx), %rsi
cmpb $0x1, (%rsi)
jne 0x10cef2
movq 0x8(%rsi), %r8
cmpq 0x17b0(%rdi), %r8
jne 0x10cef2
movq 0x10(%rsi), %r8
cmpb $0x1, (%r8)
jne 0x10cef2
movq 0x10(%r8), %r8
cmpq 0x110(%rdi), %r8
jne 0x10cef2
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %rsi
cmpb $0xa, (%rsi)
jne 0x10cef2
testb $0x1, 0x6(%rsi)
jne 0x10cef2
cmpw $0x20a, (%rsi)          # imm = 0x20A
je 0x10cef2
movq 0x10(%rsi), %r8
cmpb $0x20, (%r8)
jne 0x10ced8
movq 0x10(%r8), %r8
testb $0x2, 0x1(%r8)
jne 0x10cef2
cmpq 0x1228(%rdi), %rsi
je 0x10cef2
cmpq 0x1238(%rdi), %rsi
setne %sil
cmoveq %rax, %rdx
jmp 0x10cef7
xorl %esi, %esi
movq %rax, %rdx
testb %sil, %sil
je 0x10cf15
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0x10ce7c
movq 0x1c00(%rdi), %rax
retq
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %r8d, %r8d
je 0x10d17a
movq 0x1230(%rdi), %rax
testb $0x1, 0x2(%rax)
je 0x10d17a
cmpw $0x33, 0x4(%rcx)
jne 0x10d17a
movq 0x10(%rcx), %r8
movq 0x8(%r8), %rax
movq 0x8(%rax), %rax
movb $0x1, %dl
cmpq 0xda0(%rdi), %rax
jne 0x10d176
movq 0x10(%r8), %rax
movq 0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0x10d176
movq 0x8(%rax), %r9
cmpq 0x17b0(%rdi), %r9
jne 0x10d176
movq 0x10(%rax), %rax
movq 0x8(%rax), %r9
cmpb $0xa, (%r9)
jne 0x10d176
testb $0x1, 0x6(%r9)
jne 0x10d176
movq %r9, 0x28(%r8)
movq 0x10(%rcx), %rax
andq $-0x40001, (%rax)       # imm = 0xFFFBFFFF
movq 0x1c08(%rdi), %rax
xorl %edx, %edx
jmp 0x10d176
testb %dl, %dl
je 0x10d17d
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %r8d, %r8d
je 0x10d1f3
movq 0x1240(%rdi), %rax
testb $0x1, 0x2(%rax)
je 0x10d1f3
cmpw $0x6b, 0x4(%rcx)
jne 0x10d1f3
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rdx
movb $0x1, %cl
cmpq 0xda0(%rdi), %rdx
jne 0x10d1ef
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rdx), %r8
cmpq 0x17b0(%rdi), %r8
jne 0x10d1ef
movq 0x10(%rdx), %rdx
movq 0x8(%rdx), %rdx
cmpb $0xa, (%rdx)
jne 0x10d1ef
testb $0x1, 0x6(%rdx)
jne 0x10d1ef
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x6(%rax)
jne 0x10d1ef
movq 0x1c10(%rdi), %rax
xorl %ecx, %ecx
jmp 0x10d1ef
testb %cl, %cl
je 0x10d1f6
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10d47d
movq %rax, %r13
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10d47d
movq %r13, %rcx
orq %rax, %rcx
je 0x10d426
movq 0x11e0(%r12), %rcx
cmpq %rcx, %r13
je 0x10d43b
movq 0x10d0(%r12), %rdx
cmpq %rdx, %r13
je 0x10d455
cmpq %rcx, %rax
je 0x10d468
cmpq %rdx, %rax
je 0x10d46f
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rcx, %rax
je 0x10d429
cmpq 0x10d0(%r12), %rax
movq 0x48(%rsp), %rbx
cmovneq 0x60(%rsp), %rbx
jmp 0x10d429
cmpq %rcx, %rax
je 0x10d476
cmpq %rdx, %rax
cmovneq 0x58(%rsp), %r14
movq %r14, %rbx
jmp 0x10d429
movq 0x68(%rsp), %rbx
jmp 0x10d429
movq 0x50(%rsp), %rbx
jmp 0x10d429
movq 0x40(%rsp), %rbx
jmp 0x10d429
// File: /workspace/github_c_makefile_star2_O1/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 0x10d50f
cmpl $0x1, %eax
jne 0x10d500
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rdi), %rax
je 0x10d4f5
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0x10d50f
movzwl 0x4(%rsi), %eax
testb $0x1, %al
sete %cl
addl $-0x2, %eax
movzwl %ax, %eax
cmpl $0x168, %eax            # imm = 0x168
setae %al
orb %cl, %al
jne 0x10d50f
movl 0x4(%rsi), %eax
addl $-0x2, %eax
movzwl %ax, %eax
cmpl $0x9b, %eax
ja 0x10d50f
movq 0x18(%rsi), %rax
cmpb $0x30, (%rax)
jb 0x10d50f
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x10d509
cmpb $0x1, (%rax)
jne 0x10d509
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0x10d509
xorl %ecx, %ecx
jmp 0x10d50b
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
movq 0x8e8(%rdi,%rax,8), %rax
retq
movb $0x1, %cl
testb %cl, %cl
je 0x10d511
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10dc21
cmpb $0x1, 0x24c(%rbx)
jne 0x10dc21
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq %rax, %r12
movq 0x12c0(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x10dbc0
movq %rbx, %rdi
callq 0xb389
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 0x967ca
cmpq 0x120(%rbx), %rax
setne %al
jmp 0x10dc4e
movq 0x12c0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x40d2d(%rip), %rdx     # 0x14e960
movq 0x140(%rbx), %r8
movq 0x44e87(%rip), %r9      # 0x152ac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xb31d
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_O1/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 0x10dd1d
cmpb $0x1, 0x24c(%rbx)
jne 0x10dd1d
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq %rax, %r12
movq 0xf48(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x10dcbc
movq %rbx, %rdi
callq 0xb389
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 0x967ca
cmpq 0x120(%rbx), %rax
setne %al
jmp 0x10dd4a
movq 0xf48(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x40c31(%rip), %rdx     # 0x14e960
movq 0x140(%rbx), %r8
movq 0x44d8b(%rip), %r9      # 0x152ac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xb31d
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_O1/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:
pushq %rbx
movq %rdx, %rbx
cmpb $0xb, (%rdx)
jne 0x10ddd7
cmpq $0x0, 0x8(%rbx)
jg 0x10ddd2
movq 0x8(%rsi), %rax
movq 0x820(%rdi), %rcx
movslq 0x7dc(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0x17352(%rip), %rdx     # 0x1250e3
movq %rdx, 0x10(%rcx)
movq $0x12, 0x8(%rcx)
movq 0x1ef8(%rdi), %rdx
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ef8(%rdi), %rdx
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
popq %rbx
retq
movq 0x8(%rsi), %rsi
movq 0x140(%rdi), %rcx
movq 0x44ccf(%rip), %r8      # 0x152ab8
movq %rbx, %rdx
popq %rbx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x44b46(%rip), %rcx     # 0x1529b0
cmpb $0x0, (%rax,%rcx)
je 0x10de7b
cmpb $0xd, %al
jne 0x10de9d
movsd 0x8(%rbx), %xmm0
jmp 0x10deb3
movq 0x8(%r15), %rsi
movq 0x140(%r14), %rcx
movq 0x44c3b(%rip), %r8      # 0x152ac8
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xfac8
movq 0x44b8c(%rip), %rdi     # 0x152a30
leaq 0x50bd(%rip), %rdx      # 0x112f68
movq %rbx, %rsi
callq 0xe212
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x10df2a
movq 0x8(%r15), %rax
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r14)
leaq 0x171fd(%rip), %rdx     # 0x1250e3
movq %rdx, 0x10(%rcx)
movq $0x12, 0x8(%rcx)
movq 0x1ef8(%r14), %rdx
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%r14), %rbx
movq 0x1ef8(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq