LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_cload_directory_set
static s7_pointer g_cload_directory_set(s7_scheme *sc, s7_pointer args)
    {
        /* this sets the directory for cload.scm's output */
        s7_pointer cl_dir;
        cl_dir = cadr(args);
        if (!is_string(cl_dir))
            return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *cload-directory* to ~S", 33), cadr(args))));
        s7_symbol_set_value(sc, sc->cload_directory_symbol, cl_dir);
        if (safe_strlen(string_value(cl_dir)) > 0)
            s7_add_to_load_path(sc, (const char *)(string_value(cl_dir)));
        /* should this remove the previous *cload-directory* name first? or not affect *load-path* at all? */
        return(cl_dir);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rbx
cmpb $0x13, (%rbx)
jne 0x7ffd7
movq 0xdf8(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xbf0f
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x80043
cmpb $0x0, (%rsi)
je 0x80043
xorl %eax, %eax
cmpb $0x0, 0x1(%rsi,%rax)
leaq 0x1(%rax), %rax
jne 0x7ffbd
testq %rax, %rax
jle 0x80043
movq %r14, %rdi
callq 0x3645e
jmp 0x80043
movq 0xea8(%r14), %rbx
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x9bf5e(%rip), %rcx     # 0x11bf61
movq %rcx, 0x10(%rax)
movq $0x21, 0x8(%rax)
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%r14), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_libraries_set
static s7_pointer g_libraries_set(s7_scheme *sc, s7_pointer args) /* *libraries* setter */
    {
        s7_pointer nf;
        nf = cadr(args);
        if (is_null(nf))
            return(sc->nil);
        if (is_pair(nf))
        {
            s7_pointer p;
            if (s7_list_length(sc, nf) <= 0)
                return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *libraries* to ~S", 27), nf)));
            for (p = nf; is_pair(p); p = cdr(p))
                if ((!is_pair(car(p))) ||
                        (!is_string(caar(p))) ||
                        (!is_let(cdar(p))))
                    return(simple_wrong_type_argument_with_type(sc, sc->libraries_symbol, car(p), wrap_string(sc, "a list of conses of the form (string . let)", 43)));
            return(nf);
        }
        return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *libraries* to ~S", 27), nf)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
movq 0x110(%rdi), %r15
cmpq %r15, %r14
je 0x80330
movq %rdi, %rbx
cmpb $0x1, (%r14)
jne 0x802cd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39d0d
testq %rax, %rax
jle 0x802cd
movq %r14, %rax
movq 0x8(%rax), %rdx
cmpb $0x1, (%rdx)
jne 0x80339
movq 0x8(%rdx), %rcx
cmpb $0x13, (%rcx)
jne 0x80339
movq 0x10(%rdx), %rcx
cmpb $0x1c, (%rcx)
jne 0x80339
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x8029c
movq %r14, %r15
jmp 0x80330
movq 0xea8(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x9bc8b(%rip), %rcx     # 0x11bf83
movq %rcx, 0x10(%rax)
movq $0x1b, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38dfa
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x1250(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rdi
movq (%rax,%rdi,8), %r8
leal 0x1(%rdi), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0x9bc2f(%rip), %rax     # 0x11bf9f
movq %rax, 0x10(%r8)
movq $0x2b, 0x8(%r8)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_sharp_readers_set
static s7_pointer g_sharp_readers_set(s7_scheme *sc, s7_pointer args)
    {
        /* new value must be either () or a proper list of conses (char . func) */
        if (is_null(cadr(args))) return(cadr(args));
        if (is_pair(cadr(args)))
        {
            s7_pointer x;
            for (x = cadr(args); is_pair(x); x = cdr(x))
                if ((!is_pair(car(x))) ||
                        (!s7_is_character(caar(x))) ||
                        (!s7_is_procedure(cdar(x))))
                    return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *#readers* to ~S", 26), cadr(args))));
            if (is_null(x))
                return(cadr(args));
        }
        return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *#readers* to ~S", 26), cadr(args))));
    }

// Assembly:
pushq %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rbx
movq 0x110(%rdi), %rax
cmpq %rax, %rbx
je 0x806ac
cmpb $0x1, (%rbx)
jne 0x80644
leaq 0xcbd2d(%rip), %rdx     # 0x14c330
movq %rbx, %rcx
movq 0x8(%rcx), %r8
cmpb $0x1, (%r8)
jne 0x80644
movq 0x8(%r8), %r9
cmpb $0x8, (%r9)
jne 0x80644
movq 0x10(%r8), %r8
movzbl (%r8), %r9d
cmpb $0x0, (%r9,%rdx)
jne 0x80636
cmpb $0x14, %r9b
jne 0x80644
testb $0x20, 0x2(%r8)
je 0x80644
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0x80606
cmpq %rax, %rcx
je 0x806ac
movq 0xea8(%rdi), %rbx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rdi)
leaq 0x9b999(%rip), %rcx     # 0x11c008
movq %rcx, 0x10(%rax)
movq $0x1a, 0x8(%rax)
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %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
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_set_outlet
static s7_pointer g_set_outlet(s7_scheme *sc, s7_pointer args)
    {
        /* (let ((a 1)) (let ((b 2)) (set! (outlet (curlet)) (rootlet)) ((curlet) 'a))) */
        s7_pointer env, new_outer;

        env = car(args);
        if (!is_let(env))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 1, env, "a let"));
        if ((is_immutable(env)) || (env == sc->s7_let))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 1, env, "a mutable let"));

        new_outer = cadr(args);
        if (!is_let(new_outer))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 2, new_outer, "a let"));

        if (env != sc->rootlet)
            set_outlet(env, (new_outer == sc->rootlet) ? sc->nil : new_outer);
        return(new_outer);
    }

// Assembly:
movq 0x8(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0x8073b
testb $0x1, 0x3(%rcx)
jne 0x8074b
cmpq 0x2150(%rdi), %rcx
je 0x8074b
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
cmpb $0x1c, (%rax)
jne 0x80763
movq 0x150(%rdi), %rsi
cmpq %rsi, %rcx
je 0x8073a
movq %rax, %rdx
cmpq %rsi, %rax
jne 0x80736
movq 0x110(%rdi), %rdx
movq %rdx, 0x10(%rcx)
retq
leaq 0x9b8e1(%rip), %rsi     # 0x11c023
leaq 0x96be6(%rip), %r8      # 0x11732f
jmp 0x80759
leaq 0x9b8d1(%rip), %rsi     # 0x11c023
leaq 0x9ae2c(%rip), %r8      # 0x11b585
movl $0x1, %edx
jmp 0xd4e5
leaq 0x9b8b9(%rip), %rsi     # 0x11c023
leaq 0x96bbe(%rip), %r8      # 0x11732f
movl $0x2, %edx
movq %rax, %rcx
jmp 0xd4e5
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_set_port_line_number
static s7_pointer g_set_port_line_number(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer p, line;

        if ((is_null(car(args))) ||
                ((is_null(cdr(args))) && (is_t_integer(car(args)))))
            p = sc->input_port;
        else
        {
            p = car(args);
            if (!(is_input_port(p)))
                return(s7_wrong_type_arg_error(sc, "set! port-line-number", 1, p, "an input port"));
        }

        line = (is_null(cdr(args)) ? car(args) : cadr(args));
        if (!is_t_integer(line))
            return(s7_wrong_type_arg_error(sc, "set! port-line-number", 2, line, "an integer"));
        port_line_number(p) = integer(line);
        return(line);
    }

// Assembly:
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rax
movq 0x110(%rdi), %rdx
cmpq %rdx, %rcx
je 0x807ad
cmpq %rdx, %rax
sete %r9b
movb (%rcx), %r8b
cmpb $0xb, %r8b
sete %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x807f1
movq 0x170(%rdi), %rcx
addq $0x8, %rsi
leaq 0x8(%rax), %r8
cmpq %rdx, %rax
cmoveq %rsi, %r8
movq (%r8), %rax
cmpb $0xb, (%rax)
jne 0x807d6
movl 0x8(%rax), %edx
movq 0x8(%rcx), %rcx
movl %edx, 0x20(%rcx)
retq
leaq 0x9b852(%rip), %rsi     # 0x11c02f
leaq 0x9698e(%rip), %r8      # 0x117172
movl $0x2, %edx
movq %rax, %rcx
jmp 0xd4e5
cmpb $0x23, %r8b
je 0x807b4
leaq 0x9b831(%rip), %rsi     # 0x11c02f
leaq 0x8aeda(%rip), %r8      # 0x10b6df
movl $0x1, %edx
jmp 0xd4e5
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_set_port_position
static s7_pointer g_set_port_position(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer port, pos;
        s7_int position;

        port = car(args);
        if (!(is_input_port(port)))
            return(s7_wrong_type_arg_error(sc, "set! port-position", 1, port, "an input port"));
        if (port_is_closed(port))
            return(s7_wrong_type_arg_error(sc, "set! port-position", 1, port, "an open input port"));

        pos = cadr(args);
        if (!is_t_integer(pos))
            return(s7_wrong_type_arg_error(sc, "set! port-position", 2, pos, "an integer"));
        position = s7_integer(pos);
        if (position < 0)
            return(out_of_range(sc, sc->port_position_symbol, small_int(2), pos, its_negative_string));

        if (is_string_port(port))
            port_position(port) = position;
#if (!MS_WINDOWS)
        else
        {
            if (is_file_port(port))
            {
                rewind(port_file(port));
                fseek(port_file(port), (long)position, SEEK_SET);
            }
        }
#endif
        return(pos);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rsi), %r14
cmpb $0x23, (%r14)
jne 0x80838
movq 0x8(%r14), %rax
cmpb $0x1, 0x2(%rax)
jne 0x80858
leaq 0x9b816(%rip), %rsi     # 0x11c045
leaq 0x9ae2e(%rip), %r8      # 0x11b664
jmp 0x80846
leaq 0x9b806(%rip), %rsi     # 0x11c045
leaq 0x8ae99(%rip), %r8      # 0x10b6df
movl $0x1, %edx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xd4e5
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rbx
cmpb $0xb, (%rbx)
jne 0x8088b
movq 0x8(%rbx), %r15
testq %r15, %r15
js 0x808a3
movl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0x808fb
cmpl $0x1, %ecx
jne 0x80916
movq %r15, 0x20(%r14)
jmp 0x80916
leaq 0x9b7b3(%rip), %rsi     # 0x11c045
leaq 0x968d9(%rip), %r8      # 0x117172
movl $0x2, %edx
movq %rbx, %rcx
jmp 0x8084e
movq 0x1400(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc60ab(%rip), %rcx     # 0x146960
movq 0xca18c(%rip), %rdx     # 0x14aa48
movq 0x1ee8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
jmp 0x80916
movq 0x8(%rax), %rdi
callq 0x81e0
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x8500
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: float_vector_ref_d_7pii
static s7_double float_vector_ref_d_7pii(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2)
                {
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                            return(float_vector(v, i2 + (i1 * vector_offset(v, 0))));
                        out_of_range(sc, sc->float_vector_ref_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->float_vector_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x80cf1
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %r14, (%rdx)
jle 0x80cf1
testq %rcx, %rcx
js 0x80c78
cmpq %rcx, 0x8(%rdx)
jle 0x80c78
movq 0x18(%rax), %rax
imulq (%rax), %r14
shlq $0x3, %r14
addq 0x10(%rsi), %r14
movsd (%r14,%rcx,8), %xmm0
jmp 0x80d6d
movq 0xef0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc5cde(%rip), %rdx     # 0x146968
movq 0x1f00(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0x1ee8(%rbx), %rsi
testq %rcx, %rcx
leaq 0xc9da2(%rip), %rcx     # 0x14aa48
leaq 0xc9d93(%rip), %rdi     # 0x14aa40
cmovsq %rcx, %rdi
movq 0x1f00(%rbx), %rcx
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
movq 0xef0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc5c5d(%rip), %rcx     # 0x146960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xc9d29(%rip), %rsi     # 0x14aa48
leaq 0xc9d1a(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: float_vector_set_d_7piid
static s7_double float_vector_set_d_7piid(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_double x)
                {
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                        {
                            float_vector(v, i2 + (i1 * vector_offset(v, 0))) = x;
                            return(x);
                        }
                        out_of_range(sc, sc->float_vector_set_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->float_vector_set_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x80eed
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %r14, (%rdx)
jle 0x80eed
testq %rcx, %rcx
js 0x80e74
cmpq %rcx, 0x8(%rdx)
jle 0x80e74
movq 0x18(%rax), %rax
imulq (%rax), %r14
shlq $0x3, %r14
addq 0x10(%rsi), %r14
movsd (%rsp), %xmm0
movsd %xmm0, (%r14,%rcx,8)
jmp 0x80f66
movq 0xef8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc5ae2(%rip), %rdx     # 0x146968
movq 0x1f00(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0x1ee8(%rbx), %rsi
testq %rcx, %rcx
leaq 0xc9ba6(%rip), %rcx     # 0x14aa48
leaq 0xc9b97(%rip), %rdi     # 0x14aa40
cmovsq %rcx, %rdi
movq 0x1f00(%rbx), %rcx
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
movq 0xef8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc5a61(%rip), %rcx     # 0x146960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xc9b2d(%rip), %rsi     # 0x14aa48
leaq 0xc9b1e(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: int_vector_ref_i_7pi
static s7_int int_vector_ref_i_7pi(s7_scheme *sc, s7_pointer v, s7_int i)
                {
                    if ((i >= 0) && (i < vector_length(v)))
                        return(int_vector(v, i));
                    out_of_range(sc, sc->int_vector_ref_symbol, small_int(2), wrap_integer1(sc, i), (i < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
testq %rdx, %rdx
js 0x811f0
cmpq %rdx, 0x8(%rsi)
jle 0x811f0
movq 0x10(%rsi), %rax
movq (%rax,%rdx,8), %rax
retq
pushq %rax
movq 0xfa8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc575d(%rip), %rcx     # 0x146960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rsi
testq %rdx, %rdx
leaq 0xc9829(%rip), %rdx     # 0x14aa48
leaq 0xc981a(%rip), %r8      # 0x14aa40
cmovsq %rdx, %r8
movq 0x1f00(%rdi), %rdx
movq (%r8), %r8
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x38dfa
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: int_vector_ref_i_7pii
static s7_int int_vector_ref_i_7pii(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2)
                {
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                            return(int_vector(v, i2 + (i1 * vector_offset(v, 0))));
                        out_of_range(sc, sc->int_vector_ref_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->int_vector_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x81332
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %r14, (%rdx)
jle 0x81332
testq %rcx, %rcx
js 0x812b9
cmpq %rcx, 0x8(%rdx)
jle 0x812b9
movq 0x18(%rax), %rax
imulq (%rax), %r14
shlq $0x3, %r14
addq 0x10(%rsi), %r14
movq (%r14,%rcx,8), %rax
jmp 0x813ad
movq 0xfa8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc569d(%rip), %rdx     # 0x146968
movq 0x1f00(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0x1ee8(%rbx), %rsi
testq %rcx, %rcx
leaq 0xc9761(%rip), %rcx     # 0x14aa48
leaq 0xc9752(%rip), %rdi     # 0x14aa40
cmovsq %rcx, %rdi
movq 0x1f00(%rbx), %rcx
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
movq 0xfa8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc561c(%rip), %rcx     # 0x146960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xc96e8(%rip), %rsi     # 0x14aa48
leaq 0xc96d9(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: int_vector_set_i_7pii
static s7_int int_vector_set_i_7pii(s7_scheme *sc, s7_pointer v, s7_int i, s7_int x)
                {
                    if ((i < 0) || (i >= vector_length(v)))
                        out_of_range(sc, sc->int_vector_set_symbol, small_int(2), wrap_integer1(sc, i), (i < 0) ? its_negative_string : its_too_large_string);
                    int_vector(v, i) = x;
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rdx, %rdx
js 0x815ac
cmpq %r14, 0x8(%r15)
jg 0x81622
testq %r14, %r14
movq 0xfb0(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc539f(%rip), %rcx     # 0x146960
movq 0x1f00(%rdi), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rdi), %rdx
leaq 0xc946e(%rip), %rsi     # 0x14aa48
leaq 0xc945f(%rip), %r8      # 0x14aa40
cmovsq %rsi, %r8
movq 0x1f00(%rdi), %rsi
movq (%r8), %r8
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x38dfa
movq 0x10(%r15), %rax
movq %rbx, (%rax,%r14,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: int_vector_set_i_7piii
static s7_int int_vector_set_i_7piii(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_int i3)
                {
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                        {
                            int_vector(v, i2 + (i1 * vector_offset(v, 0))) = i3;
                            return(i3);
                        }
                        out_of_range(sc, sc->int_vector_set_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->int_vector_set_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x816fa
movq 0x18(%rsi), %rdx
movq 0x20(%rdx), %rdx
movq (%rdx), %rdi
cmpq %r14, (%rdi)
jle 0x816fa
testq %rcx, %rcx
js 0x81681
cmpq %rcx, 0x8(%rdi)
jle 0x81681
movq %r8, %rax
movq 0x18(%rdx), %rdx
imulq (%rdx), %r14
shlq $0x3, %r14
addq 0x10(%rsi), %r14
movq %r8, (%r14,%rcx,8)
jmp 0x81775
movq 0xfb0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc52d5(%rip), %rdx     # 0x146968
movq 0x1f00(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0x1ee8(%rbx), %rsi
testq %rcx, %rcx
leaq 0xc9399(%rip), %rcx     # 0x14aa48
leaq 0xc938a(%rip), %rdi     # 0x14aa40
cmovsq %rcx, %rdi
movq 0x1f00(%rbx), %rcx
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
movq 0xfb0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc5254(%rip), %rcx     # 0x146960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xc9320(%rip), %rsi     # 0x14aa48
leaq 0xc9311(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_ref_i_7pi
static s7_int byte_vector_ref_i_7pi(s7_scheme *sc, s7_pointer p1, s7_int i1)
                {
                    if ((i1 >= 0) && (i1 < byte_vector_length(p1)))
                        return((s7_int)((byte_vector(p1, i1))));
                    out_of_range(sc, sc->byte_vector_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
testq %rdx, %rdx
js 0x81791
cmpq %rdx, 0x8(%rsi)
jle 0x81791
movq 0x10(%rsi), %rax
movzbl (%rax,%rdx), %eax
retq
pushq %rax
movq 0xc30(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc51bc(%rip), %rcx     # 0x146960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rsi
testq %rdx, %rdx
leaq 0xc9288(%rip), %rdx     # 0x14aa48
leaq 0xc9279(%rip), %r8      # 0x14aa40
cmovsq %rdx, %r8
movq 0x1f00(%rdi), %rdx
movq (%r8), %r8
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x38dfa
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_ref_i_7pii
static s7_int byte_vector_ref_i_7pii(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2)
                {
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                            return((s7_int)byte_vector(v, i2 + (i1 * vector_offset(v, 0))));
                        out_of_range(sc, sc->byte_vector_ref_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->byte_vector_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x818d0
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %r14, (%rdx)
jle 0x818d0
testq %rcx, %rcx
js 0x81857
cmpq %rcx, 0x8(%rdx)
jle 0x81857
movq 0x18(%rax), %rax
imulq (%rax), %r14
addq 0x10(%rsi), %r14
movzbl (%rcx,%r14), %eax
jmp 0x8194b
movq 0xc30(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc50ff(%rip), %rdx     # 0x146968
movq 0x1f00(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0x1ee8(%rbx), %rsi
testq %rcx, %rcx
leaq 0xc91c3(%rip), %rcx     # 0x14aa48
leaq 0xc91b4(%rip), %rdi     # 0x14aa40
cmovsq %rcx, %rdi
movq 0x1f00(%rbx), %rcx
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
movq 0xc30(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc507e(%rip), %rcx     # 0x146960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xc914a(%rip), %rsi     # 0x14aa48
leaq 0xc913b(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_set_i_7pii
static s7_int byte_vector_set_i_7pii(s7_scheme *sc, s7_pointer p1, s7_int i1, s7_int i2)
                {
                    if (!is_byte_vector(p1))
                        simple_wrong_type_argument_with_type(sc, sc->byte_vector_set_symbol, p1, a_byte_vector_string);
                    if ((i2 < 0) || (i2 > 255))
                        simple_wrong_type_argument_with_type(sc, sc->byte_vector_set_symbol, wrap_integer1(sc, i2), an_unsigned_byte_string);
                    if ((i1 >= 0) && (i1 < byte_vector_length(p1)))
                        byte_vector(p1, i1) = (uint8_t)i2;
                    else simple_out_of_range(sc, sc->byte_vector_set_symbol, wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(i2);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpb $0x18, (%rsi)
je 0x81990
movq 0xc38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xd3c93(%rip), %r8      # 0x155618
movq %r14, %rdi
movq %r12, %rdx
callq 0xed2a
cmpq $0x100, %rbx            # imm = 0x100
jb 0x819cc
movq 0xc38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x1f00(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x1f00(%r14), %rdx
movq 0x140(%r14), %rcx
movq 0xd169c(%rip), %r8      # 0x153060
movq %r14, %rdi
callq 0xed2a
testq %r15, %r15
js 0x819e3
cmpq %r15, 0x8(%r12)
jle 0x819e3
movq 0x10(%r12), %rax
movb %bl, (%rax,%r15)
jmp 0x81a4d
movq 0xc38(%r14), %rax
movq 0x8(%rax), %rax
movq 0x1f00(%r14), %rcx
movq %r15, 0x8(%rcx)
movq 0x1ef8(%r14), %rcx
movq 0x1f00(%r14), %rdx
testq %r15, %r15
leaq 0xc9037(%rip), %rsi     # 0x14aa48
leaq 0xc9028(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq (%rdi), %rsi
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%r14), %rsi
movq 0x1ef8(%r14), %rdx
movq %r14, %rdi
callq 0x38dfa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_set_i_7piii
static s7_int byte_vector_set_i_7piii(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_int i3)
                {
                    if ((i3 < 0) || (i3 > 255))
                        simple_wrong_type_argument_with_type(sc, sc->byte_vector_set_symbol, wrap_integer1(sc, i3), an_unsigned_byte_string);
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                        {
                            byte_vector(v, i2 + (i1 * vector_offset(v, 0))) = i3;
                            return(i3);
                        }
                        out_of_range(sc, sc->int_vector_set_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->int_vector_set_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
cmpq $0x100, %r8             # imm = 0x100
jb 0x81ab0
movq 0xc38(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x1f00(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x1f00(%rbx), %rdx
movq 0x140(%rbx), %rcx
movq 0xd15b8(%rip), %r8      # 0x153060
movq %rbx, %rdi
callq 0xed2a
testq %r14, %r14
js 0x81b66
movq 0x18(%r13), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %r14, (%rcx)
jle 0x81b66
testq %r12, %r12
js 0x81aed
cmpq %r12, 0x8(%rcx)
jle 0x81aed
movq 0x18(%rax), %rax
imulq (%rax), %r14
addq 0x10(%r13), %r14
movb %r15b, (%r12,%r14)
jmp 0x81be2
movq 0xfb0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc4e69(%rip), %rcx     # 0x146968
movq 0x1f00(%rbx), %rdx
movq %r12, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r12, %r12
leaq 0xc8f2d(%rip), %rsi     # 0x14aa48
leaq 0xc8f1e(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
movq 0xfb0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc4de8(%rip), %rcx     # 0x146960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xc8eb4(%rip), %rsi     # 0x14aa48
leaq 0xc8ea5(%rip), %rdi     # 0x14aa40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x38dfa
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_ref_p_pp
static inline s7_pointer vector_ref_p_pp(s7_scheme *sc, s7_pointer vec, s7_pointer ind)
                {
                    s7_int index;
                    if ((!is_any_vector(vec)) ||
                            (vector_rank(vec) != 1) ||
                            (!s7_is_integer(ind)))
                        return(g_vector_ref(sc, set_plist_2(sc, vec, ind)));
                    index = s7_integer(ind);
                    if ((index < 0) || (index >= vector_length(vec)))
                        return(out_of_range(sc, sc->vector_ref_symbol, small_int(2), ind, (index < 0) ? its_negative_string : its_too_large_string));
                    return(vector_getter(vec)(sc, vec, index));
                }

// Assembly:
movzbl (%rsi), %eax
leaq 0xc9027(%rip), %rcx     # 0x14ac20
cmpb $0x1, (%rax,%rcx)
jne 0x81c30
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x81c13
cmpq $0x1, 0x10(%rax)
jne 0x81c30
cmpb $0xb, (%rdx)
jne 0x81c30
movq 0x8(%rdx), %rax
testq %rax, %rax
js 0x81c52
cmpq 0x8(%rsi), %rax
jge 0x81c52
movq 0x20(%rsi), %rcx
movq %rax, %rdx
jmpq *%rcx
movq 0x708(%rdi), %rax
movq %rsi, 0x8(%rax)
movq 0x710(%rdi), %rax
movq %rdx, 0x8(%rax)
movq 0x708(%rdi), %rsi
jmp 0x79c8d
testq %rax, %rax
movq 0x1660(%rdi), %rax
movq 0x8(%rax), %rax
leaq 0xc8de1(%rip), %rcx     # 0x14aa48
leaq 0xc8dd2(%rip), %rsi     # 0x14aa40
cmovsq %rcx, %rsi
movq 0xc4ce7(%rip), %rcx     # 0x146960
movq (%rsi), %rsi
movq 0x1ee8(%rdi), %r8
movq 0x10(%r8), %r8
movq %rax, 0x8(%r8)
movq 0x10(%r8), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
jmp 0x38dfa
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_ref_p_pi
static s7_pointer vector_ref_p_pi(s7_scheme *sc, s7_pointer v, s7_int i)
                {
                    if ((!is_any_vector(v)) ||
                            (vector_rank(v) > 1) ||
                            (i < 0) ||
                            (i >= vector_length(v)))
                        return(g_vector_ref(sc, set_plist_2(sc, v, make_integer(sc, i))));
                    return(vector_getter(v)(sc, v, i));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
leaq 0xc8f52(%rip), %rcx     # 0x14ac20
cmpb $0x1, (%rax,%rcx)
jne 0x81d10
movq 0x18(%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x81ceb
cmpq $0x2, 0x10(%rax)
setge %al
jmp 0x81ced
xorl %eax, %eax
testq %r15, %r15
js 0x81d10
testb %al, %al
jne 0x81d10
cmpq %r15, 0x8(%r14)
jle 0x81d10
movq 0x20(%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0x81d26
leaq 0xc4c30(%rip), %rax     # 0x146950
movq (%rax,%r15,8), %rax
jmp 0x81d5f
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x81d45
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
movq 0x708(%rbx), %rcx
movq %r14, 0x8(%rcx)
movq 0x710(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x708(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x79c8d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_ref_p_pii
static s7_pointer vector_ref_p_pii(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2)
                {
                    if ((!is_any_vector(v)) ||
                            (vector_rank(v) != 2) ||
                            (i1 < 0) || (i2 < 0) ||
                            (i1 >= vector_dimension(v, 0)) ||
                            (i2 >= vector_dimension(v, 1)))
                        return(g_vector_ref(sc, set_plist_3(sc, v, make_integer(sc, i1), make_integer(sc, i2))));
                    return(vector_getter(v)(sc, v, i2 + (i1 * vector_offset(v, 0))));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
leaq 0xc8e76(%rip), %rcx     # 0x14ac20
cmpb $0x1, (%rax,%rcx)
jne 0x81e02
movq 0x18(%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x81e02
movq %r15, %rcx
orq %r12, %rcx
js 0x81e02
cmpq $0x2, 0x10(%rax)
jne 0x81e02
movq (%rax), %rcx
cmpq %r12, (%rcx)
jle 0x81e02
cmpq %r15, 0x8(%rcx)
jle 0x81e02
movq 0x20(%r14), %rcx
movq 0x18(%rax), %rax
imulq (%rax), %r12
addq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
leaq 0xc4b47(%rip), %rbp     # 0x146950
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0x81e19
movq (%rbp,%r12,8), %r13
jmp 0x81e53
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x81e38
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r13
movq $0xb, (%r13)
movq %r12, 0x8(%r13)
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0x81e63
movq (%rbp,%r15,8), %rax
jmp 0x81e9c
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x81e82
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
movq 0x718(%rbx), %rsi
movq %r14, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %r13, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x79c8d
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_set_p_pip
static s7_pointer vector_set_p_pip(s7_scheme *sc, s7_pointer v, s7_int i, s7_pointer p)
                {
                    if ((!is_any_vector(v)) ||
                            (vector_rank(v) > 1) ||
                            (i < 0) ||
                            (i >= vector_length(v)))
                        return(g_vector_set(sc, set_plist_3(sc, v, make_integer(sc, i), p)));

                    if (is_typed_vector(v))
                        return(typed_vector_setter(sc, v, i, p));

                    vector_setter(v)(sc, v, i, p);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rsi), %eax
leaq 0xc8d35(%rip), %rcx     # 0x14ac20
cmpb $0x1, (%rax,%rcx)
jne 0x81f39
movq 0x18(%r15), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x81f08
cmpq $0x2, 0x10(%rax)
setge %al
jmp 0x81f0a
xorl %eax, %eax
testq %r12, %r12
js 0x81f39
testb %al, %al
jne 0x81f39
cmpq %r12, 0x8(%r15)
jle 0x81f39
testb $0x2, 0x6(%r15)
jne 0x81fb6
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x28(%r15)
jmp 0x82011
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0x81f4f
leaq 0xc4a07(%rip), %rax     # 0x146950
movq (%rax,%r12,8), %rax
jmp 0x81f88
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x81f6e
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r12, 0x8(%rax)
movq 0x718(%r14), %rsi
movq %r15, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rbx, 0x8(%rax)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x79cc5
cmpq $0x0, 0x6a0(%r14)
js 0x82009
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0x81fe6
movq 0x10(%rsi), %rax
movq 0x700(%r14), %rcx
movq %rbx, 0x8(%rcx)
movq 0x700(%r14), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x82000
movq 0x700(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x700(%r14), %rdx
movq %r14, %rdi
callq 0xaee6
cmpq 0x120(%r14), %rax
je 0x82020
movq 0x10(%r15), %rax
movq %rbx, (%rax,%r12,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%r15), %rsi
cmpb $0x30, (%rsi)
jb 0x8202f
movq 0x8(%rsi), %rax
jmp 0x82043
movq 0x18(%rsi), %rdx
movq %r14, %rdi
callq 0x99caa
movq 0x8(%rax), %rax
addq $0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x99bbf
leaq 0x90afe(%rip), %rsi     # 0x112b58
movl $0x3, %edx
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd4e5
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_ref_p_pi_direct
static s7_pointer vector_ref_p_pi_direct(s7_scheme *sc, s7_pointer v, s7_int i)
                {
                    if ((i >= 0) && (i < vector_length(v)))
                        return(vector_getter(v)(sc, v, i));
                    out_of_range(sc, sc->vector_ref_symbol, small_int(2), wrap_integer1(sc, i), (i < 0) ? its_negative_string : its_too_large_string);
                    return(v);
                }

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
js 0x822d8
cmpq %rdx, 0x8(%rbx)
jle 0x822d8
movq 0x20(%rbx), %rax
movq %rbx, %rsi
popq %rbx
jmpq *%rax
movq 0x1660(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc4676(%rip), %rcx     # 0x146960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rsi
testq %rdx, %rdx
leaq 0xc8742(%rip), %rdx     # 0x14aa48
leaq 0xc8733(%rip), %r8      # 0x14aa40
cmovsq %rdx, %r8
movq 0x1f00(%rdi), %rdx
movq (%r8), %r8
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_set_p_pip_direct
static s7_pointer vector_set_p_pip_direct(s7_scheme *sc, s7_pointer v, s7_int i, s7_pointer p)
                {
                    if ((i >= 0) && (i < vector_length(v)))
                        vector_element(v, i) = p;
                    else out_of_range(sc, sc->vector_set_symbol, small_int(2), wrap_integer1(sc, i), (i < 0) ? its_negative_string : its_too_large_string);
                    return(p);
                }

// Assembly:
pushq %rbx
movq %rcx, %rbx
testq %rdx, %rdx
js 0x8236c
cmpq %rdx, 0x8(%rsi)
jle 0x8236c
movq 0x10(%rsi), %rax
movq %rbx, (%rax,%rdx,8)
jmp 0x823e2
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc45e2(%rip), %rcx     # 0x146960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rsi
testq %rdx, %rdx
leaq 0xc86ae(%rip), %rdx     # 0x14aa48
leaq 0xc869f(%rip), %r8      # 0x14aa40
cmovsq %rdx, %r8
movq 0x1f00(%rdi), %rdx
movq (%r8), %r8
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: vector_set_p_ppp
static s7_pointer vector_set_p_ppp(s7_scheme *sc, s7_pointer vec, s7_pointer ind, s7_pointer val)
                {
                    s7_int index;

                    if ((!is_any_vector(vec)) || (vector_rank(vec) > 1))
                        return(g_vector_set(sc, set_plist_3(sc, vec, ind, val)));
                    if (is_immutable_vector(vec))
                        return(immutable_object_error(sc, set_elist_3(sc, immutable_error_string, sc->vector_set_symbol, vec)));
                    if (!s7_is_integer(ind))
                        return(g_vector_set(sc, set_plist_3(sc, vec, ind, val)));
                    index = s7_integer(ind);
                    if ((index < 0) ||
                            (index >= vector_length(vec)))
                        return(out_of_range(sc, sc->vector_set_symbol, small_int(2), wrap_integer1(sc, index), (index < 0) ? its_negative_string : its_too_large_string));

                    if (is_typed_vector(vec))
                        return(typed_vector_setter(sc, vec, index, val));
                    vector_setter(vec)(sc, vec, index, val);
                    return(val);
                }

// Assembly:
pushq %rbx
movq %rcx, %rbx
movzbl (%rsi), %eax
leaq 0xc882b(%rip), %rcx     # 0x14ac20
cmpb $0x1, (%rax,%rcx)
jne 0x82442
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x8240f
cmpq $0x2, 0x10(%rax)
jge 0x82442
movq (%rsi), %rax
btl $0x18, %eax
jb 0x82466
cmpb $0xb, (%rdx)
jne 0x82442
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0x8249f
cmpq 0x8(%rsi), %rdx
jge 0x8249f
btq $0x31, %rax
jb 0x8251d
movq %rbx, %rcx
callq *0x28(%rsi)
jmp 0x82518
movq 0x718(%rdi), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rbx, 0x8(%rcx)
movq %rax, %rsi
popq %rbx
jmp 0x79cc5
movq 0xc84fb(%rip), %rax     # 0x14a968
movq 0x1668(%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 0x82510
testq %rdx, %rdx
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc44ac(%rip), %rcx     # 0x146960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rdx
leaq 0xc857b(%rip), %rsi     # 0x14aa48
leaq 0xc856c(%rip), %r8      # 0x14aa40
cmovsq %rsi, %r8
movq 0x1f00(%rdi), %rsi
movq (%r8), %r8
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
movq %rbx, %rcx
popq %rbx
jmp 0x3b5f6