LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x67122
movq %rdi, %rbx
cmpb $0x1, (%r14)
jne 0x670bf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2dada
testq %rax, %rax
jle 0x670bf
movb $0x1, %cl
movq %r14, %rax
cmpb $0x1, %cl
jne 0x6717b
movq 0x8(%rax), %rdx
cmpb $0x1, (%rdx)
jne 0x6712b
movq 0x8(%rdx), %rcx
cmpb $0x13, (%rcx)
jne 0x6712b
movq 0x10(%rdx), %rcx
cmpb $0x1c, (%rcx)
jne 0x6712b
movq 0x10(%rax), %rax
movb (%rax), %cl
jmp 0x6708f
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 0x80e39(%rip), %rcx     # 0xe7f23
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 0x2cdc0
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 0x80ddd(%rip), %rax     # 0xe7f3f
movq %rax, 0x10(%r8)
movq $0x2b, 0x8(%r8)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xd456
movq %r14, %r15
jmp 0x67122
// File: /workspace/github_c_makefile_star2_O2/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 0x67415
cmpb $0x1, (%rbx)
jne 0x673ad
movb $0x1, %r8b
leaq 0xb3fca(%rip), %rcx     # 0x11b330
movq %rbx, %rdx
cmpb $0x1, %r8b
jne 0x673a8
movq 0x8(%rdx), %r8
cmpb $0x1, (%r8)
jne 0x673ad
movq 0x8(%r8), %r9
cmpb $0x8, (%r9)
jne 0x673ad
movq 0x10(%r8), %r8
movzbl (%r8), %r9d
cmpb $0x0, (%r9,%rcx)
jne 0x6739f
cmpb $0x14, %r9b
jne 0x673ad
testb $0x20, 0x2(%r8)
je 0x673ad
movq 0x10(%rdx), %rdx
movb (%rdx), %r8b
jmp 0x67369
cmpq %rax, %rdx
je 0x67415
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 0x80bd0(%rip), %rcx     # 0xe7fa8
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 0x2cdc0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6748e
testb $0x1, 0x3(%rcx)
jne 0x6749e
cmpq 0x2150(%rdi), %rcx
je 0x6749e
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
cmpb $0x1c, (%rax)
jne 0x674b4
movq 0x150(%rdi), %rsi
cmpq %rsi, %rcx
je 0x6748d
movq %rax, %rdx
cmpq %rsi, %rax
jne 0x67489
movq 0x110(%rdi), %rdx
movq %rdx, 0x10(%rcx)
retq
leaq 0x80b2e(%rip), %rsi     # 0xe7fc3
leaq 0x7be33(%rip), %r8      # 0xe32cf
jmp 0x674ac
leaq 0x80b1e(%rip), %rsi     # 0xe7fc3
leaq 0x80079(%rip), %r8      # 0xe7525
pushq $0x1
popq %rdx
jmp 0xc2b0
leaq 0x80b08(%rip), %rsi     # 0xe7fc3
leaq 0x7be0d(%rip), %r8      # 0xe32cf
pushq $0x2
popq %rdx
movq %rax, %rcx
jmp 0xc2b0
// File: /workspace/github_c_makefile_star2_O2/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 0x674fc
cmpq %rdx, %rax
sete %r9b
movb (%rcx), %r8b
cmpb $0xb, %r8b
sete %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x6753e
movq 0x170(%rdi), %rcx
addq $0x8, %rsi
leaq 0x8(%rax), %r8
cmpq %rdx, %rax
cmoveq %rsi, %r8
movq (%r8), %rax
cmpb $0xb, (%rax)
jne 0x67525
movl 0x8(%rax), %edx
movq 0x8(%rcx), %rcx
movl %edx, 0x20(%rcx)
retq
leaq 0x80aa3(%rip), %rsi     # 0xe7fcf
leaq 0x7bbdf(%rip), %r8      # 0xe3112
pushq $0x2
popq %rdx
movq %rax, %rcx
jmp 0xc2b0
cmpb $0x23, %r8b
je 0x67503
leaq 0x80a84(%rip), %rsi     # 0xe7fcf
leaq 0x7012d(%rip), %r8      # 0xd767f
pushq $0x1
popq %rdx
jmp 0xc2b0
// File: /workspace/github_c_makefile_star2_O2/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 0x67583
movq 0x8(%r14), %rax
cmpb $0x1, 0x2(%rax)
jne 0x675a1
leaq 0x80a6b(%rip), %rsi     # 0xe7fe5
leaq 0x80083(%rip), %r8      # 0xe7604
jmp 0x67591
leaq 0x80a5b(%rip), %rsi     # 0xe7fe5
leaq 0x700ee(%rip), %r8      # 0xd767f
pushq $0x1
popq %rdx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xc2b0
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rbx
cmpb $0xb, (%rbx)
jne 0x675c9
movq 0x8(%rbx), %r15
testq %r15, %r15
js 0x675df
movl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0x67605
cmpl $0x1, %ecx
jne 0x67620
movq %r15, 0x20(%r14)
jmp 0x67620
leaq 0x80a15(%rip), %rsi     # 0xe7fe5
leaq 0x7bb3b(%rip), %r8      # 0xe3112
pushq $0x2
popq %rdx
movq %rbx, %rcx
jmp 0x67597
movq 0x1400(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xae36f(%rip), %rdx     # 0x115960
movq 0xb2450(%rip), %r8      # 0x119a48
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xcb8f
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_O2/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, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x6795d
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %rbx, (%rdx)
jle 0x6795d
testq %rcx, %rcx
js 0x67916
cmpq %rcx, 0x8(%rdx)
jle 0x67916
movq 0x18(%rax), %rax
imulq (%rax), %rbx
shlq $0x3, %rbx
addq 0x10(%rsi), %rbx
movsd (%rbx,%rcx,8), %xmm0
jmp 0x679a4
movq 0xef0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xae040(%rip), %rdx     # 0x115968
movq 0x1f00(%r14), %rax
movq %rcx, 0x8(%rax)
movq 0x1f00(%r14), %rax
testq %rcx, %rcx
leaq 0xb2104(%rip), %rcx     # 0x119a48
leaq 0xb20f5(%rip), %rdi     # 0x119a40
cmovsq %rcx, %rdi
movq (%rdi), %r8
movq %r14, %rdi
movq %rax, %rcx
callq 0xcb8f
movq 0xef0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xadff1(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %rbx, %rbx
leaq 0xb20bd(%rip), %rax     # 0x119a48
leaq 0xb20ae(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x67ab4
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %rbx, (%rdx)
jle 0x67ab4
testq %rcx, %rcx
js 0x67a6d
cmpq %rcx, 0x8(%rdx)
jle 0x67a6d
movq 0x18(%rax), %rax
imulq (%rax), %rbx
shlq $0x3, %rbx
addq 0x10(%rsi), %rbx
movsd (%rsp), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
jmp 0x67af8
movq 0xef8(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xadee9(%rip), %rdx     # 0x115968
movq 0x1f00(%r14), %rax
movq %rcx, 0x8(%rax)
movq 0x1f00(%r14), %rax
testq %rcx, %rcx
leaq 0xb1fad(%rip), %rcx     # 0x119a48
leaq 0xb1f9e(%rip), %rdi     # 0x119a40
cmovsq %rcx, %rdi
movq (%rdi), %r8
movq %r14, %rdi
movq %rax, %rcx
callq 0xcb8f
movq 0xef8(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xade9a(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %rbx, %rbx
leaq 0xb1f66(%rip), %rax     # 0x119a48
leaq 0xb1f57(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x67d54
cmpq %rdx, 0x8(%rsi)
jle 0x67d54
movq 0x10(%rsi), %rax
movq (%rax,%rdx,8), %rax
retq
pushq %rax
movq 0xfa8(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xadbf9(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
testq %rdx, %rdx
leaq 0xb1cc5(%rip), %rdx     # 0x119a48
leaq 0xb1cb6(%rip), %r8      # 0x119a40
cmovsq %rdx, %r8
movq (%r8), %r8
movq %rax, %rdx
callq 0xcb8f
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x67e35
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %rbx, (%rdx)
jle 0x67e35
testq %rcx, %rcx
js 0x67dee
cmpq %rcx, 0x8(%rdx)
jle 0x67dee
movq 0x18(%rax), %rax
imulq (%rax), %rbx
shlq $0x3, %rbx
addq 0x10(%rsi), %rbx
movq (%rbx,%rcx,8), %rax
jmp 0x67e7b
movq 0xfa8(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xadb68(%rip), %rdx     # 0x115968
movq 0x1f00(%r14), %rax
movq %rcx, 0x8(%rax)
movq 0x1f00(%r14), %rax
testq %rcx, %rcx
leaq 0xb1c2c(%rip), %rcx     # 0x119a48
leaq 0xb1c1d(%rip), %rdi     # 0x119a40
cmovsq %rcx, %rdi
movq (%rdi), %r8
movq %r14, %rdi
movq %rax, %rcx
callq 0xcb8f
movq 0xfa8(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xadb19(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %rbx, %rbx
leaq 0xb1be5(%rip), %rax     # 0x119a48
leaq 0xb1bd6(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: int_vector_ref_i_7piii
static s7_int int_vector_ref_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)))
                        {
                            if ((i3 >= 0) && (i3 < vector_dimension(v, 2)))
                                return(int_vector(v, i3 + (i2 * vector_offset(v, 1)) + (i1 * vector_offset(v, 0))));
                            out_of_range(sc, sc->int_vector_ref_symbol, small_int(4), wrap_integer1(sc, i3), (i3 < 0) ? its_negative_string : its_too_large_string);
                        }
                        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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x67f79
movq %rcx, %r15
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %rbx, (%rcx)
jle 0x67f79
testq %r15, %r15
js 0x67f35
cmpq %r15, 0x8(%rcx)
jle 0x67f35
testq %r8, %r8
js 0x67ef1
cmpq %r8, 0x10(%rcx)
jle 0x67ef1
movq 0x18(%rax), %rax
imulq 0x8(%rax), %r15
imulq (%rax), %rbx
shlq $0x3, %r15
addq 0x10(%rsi), %r15
leaq (%r15,%r8,8), %rax
movq (%rax,%rbx,8), %rax
jmp 0x67fbf
movq 0xfa8(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xada6d(%rip), %rdx     # 0x115970
movq 0x1f00(%r14), %rax
movq %r8, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %r8, %r8
leaq 0xb1b29(%rip), %rax     # 0x119a48
leaq 0xb1b1a(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
movq 0xfa8(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xada21(%rip), %rdx     # 0x115968
movq 0x1f00(%r14), %rax
movq %r15, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %r15, %r15
leaq 0xb1ae5(%rip), %rax     # 0x119a48
leaq 0xb1ad6(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
movq 0xfa8(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xad9d5(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %rbx, %rbx
leaq 0xb1aa1(%rip), %rax     # 0x119a48
leaq 0xb1a92(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x67fde
cmpq %r14, 0x8(%r15)
jg 0x6801f
testq %r14, %r14
movq 0xfb0(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xad96d(%rip), %rdx     # 0x115960
movq 0x1f00(%rdi), %rax
movq %r14, 0x8(%rax)
movq 0x1f00(%rdi), %rcx
leaq 0xb1a3c(%rip), %rax     # 0x119a48
leaq 0xb1a2d(%rip), %r8      # 0x119a40
cmovsq %rax, %r8
movq (%r8), %r8
callq 0xcb8f
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_O2/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, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x680bd
movq 0x18(%rsi), %rdx
movq 0x20(%rdx), %rdx
movq (%rdx), %rdi
cmpq %rbx, (%rdi)
jle 0x680bd
testq %rcx, %rcx
js 0x68076
cmpq %rcx, 0x8(%rdi)
jle 0x68076
movq %r8, %rax
movq 0x18(%rdx), %rdx
imulq (%rdx), %rbx
shlq $0x3, %rbx
addq 0x10(%rsi), %rbx
movq %r8, (%rbx,%rcx,8)
jmp 0x68103
movq 0xfb0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xad8e0(%rip), %rdx     # 0x115968
movq 0x1f00(%r14), %rax
movq %rcx, 0x8(%rax)
movq 0x1f00(%r14), %rax
testq %rcx, %rcx
leaq 0xb19a4(%rip), %rcx     # 0x119a48
leaq 0xb1995(%rip), %rdi     # 0x119a40
cmovsq %rcx, %rdi
movq (%rdi), %r8
movq %r14, %rdi
movq %rax, %rcx
callq 0xcb8f
movq 0xfb0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xad891(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %rbx, %rbx
leaq 0xb195d(%rip), %rax     # 0x119a48
leaq 0xb194e(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6811f
cmpq %rdx, 0x8(%rsi)
jle 0x6811f
movq 0x10(%rsi), %rax
movzbl (%rax,%rdx), %eax
retq
pushq %rax
movq 0xc30(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xad82e(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
testq %rdx, %rdx
leaq 0xb18fa(%rip), %rdx     # 0x119a48
leaq 0xb18eb(%rip), %r8      # 0x119a40
cmovsq %rdx, %r8
movq (%r8), %r8
movq %rax, %rdx
callq 0xcb8f
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
testq %rdx, %rdx
js 0x681f1
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %rbx, (%rdx)
jle 0x681f1
testq %rcx, %rcx
js 0x681aa
cmpq %rcx, 0x8(%rdx)
jle 0x681aa
movq 0x18(%rax), %rax
imulq (%rax), %rbx
addq 0x10(%rsi), %rbx
movzbl (%rcx,%rbx), %eax
jmp 0x68237
movq 0xc30(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xad7ac(%rip), %rdx     # 0x115968
movq 0x1f00(%r14), %rax
movq %rcx, 0x8(%rax)
movq 0x1f00(%r14), %rax
testq %rcx, %rcx
leaq 0xb1870(%rip), %rcx     # 0x119a48
leaq 0xb1861(%rip), %rdi     # 0x119a40
cmovsq %rcx, %rdi
movq (%rdi), %r8
movq %r14, %rdi
movq %rax, %rcx
callq 0xcb8f
movq 0xc30(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xad75d(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %rbx, %rbx
leaq 0xb1829(%rip), %rax     # 0x119a48
leaq 0xb181a(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6827c
movq 0xc38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x140(%r14), %rcx
movq 0xbc3a7(%rip), %r8      # 0x124618
movq %r14, %rdi
movq %r12, %rdx
callq 0xd456
cmpq $0x100, %rbx            # imm = 0x100
jb 0x682b8
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 0xb9db0(%rip), %r8      # 0x122060
movq %r14, %rdi
callq 0xd456
testq %r15, %r15
js 0x682cf
cmpq %r15, 0x8(%r12)
jle 0x682cf
movq 0x10(%r12), %rax
movb %bl, (%rax,%r15)
jmp 0x6830c
movq 0xc38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x1f00(%r14), %rax
movq %r15, 0x8(%rax)
movq 0x1f00(%r14), %rdx
testq %r15, %r15
leaq 0xb1752(%rip), %rax     # 0x119a48
leaq 0xb1743(%rip), %rcx     # 0x119a40
cmovsq %rax, %rcx
movq (%rcx), %rcx
movq %r14, %rdi
callq 0x35b47
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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, %rbx
movq %rsi, %r13
movq %rdi, %r14
cmpq $0x100, %r8             # imm = 0x100
jb 0x6836f
movq 0xc38(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x1f00(%r14), %rax
movq %r15, 0x8(%rax)
movq 0x1f00(%r14), %rdx
movq 0x140(%r14), %rcx
movq 0xb9cf9(%rip), %r8      # 0x122060
movq %r14, %rdi
callq 0xd456
testq %rbx, %rbx
js 0x683e8
movq 0x18(%r13), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
cmpq %rbx, (%rcx)
jle 0x683e8
testq %r12, %r12
js 0x683a4
cmpq %r12, 0x8(%rcx)
jle 0x683a4
movq 0x18(%rax), %rax
imulq (%rax), %rbx
addq 0x10(%r13), %rbx
movb %r15b, (%r12,%rbx)
jmp 0x6842f
movq 0xfb0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xad5b2(%rip), %rdx     # 0x115968
movq 0x1f00(%r14), %rax
movq %r12, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %r12, %r12
leaq 0xb1676(%rip), %rax     # 0x119a48
leaq 0xb1667(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
movq 0xfb0(%r14), %rax
movq 0x8(%rax), %rsi
movq 0xad566(%rip), %rdx     # 0x115960
movq 0x1f00(%r14), %rax
movq %rbx, 0x8(%rax)
movq 0x1f00(%r14), %rcx
testq %rbx, %rbx
leaq 0xb1632(%rip), %rax     # 0x119a48
leaq 0xb1623(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %r14, %rdi
callq 0xcb8f
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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:
movq %rdx, %rcx
movzbl (%rsi), %eax
leaq 0xb17d7(%rip), %rdx     # 0x119c20
cmpb $0x1, (%rax,%rdx)
jne 0x6847d
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x68463
cmpq $0x1, 0x10(%rax)
jne 0x6847d
cmpb $0xb, (%rcx)
jne 0x6847d
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
js 0x6849f
cmpq 0x8(%rsi), %rdx
jge 0x6849f
movq 0x20(%rsi), %rax
jmpq *%rax
movq 0x708(%rdi), %rax
movq %rsi, 0x8(%rax)
movq 0x710(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x708(%rdi), %rsi
jmp 0x6278d
testq %rdx, %rdx
movq 0x1660(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xad4ac(%rip), %rdx     # 0x115960
leaq 0xb158d(%rip), %rax     # 0x119a48
leaq 0xb157e(%rip), %r8      # 0x119a40
cmovsq %rax, %r8
movq (%r8), %r8
jmp 0xcb8f
// File: /workspace/github_c_makefile_star2_O2/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 0xb172f(%rip), %rcx     # 0x119c20
cmpb $0x1, (%rax,%rcx)
jne 0x68533
movq 0x18(%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x6850e
cmpq $0x2, 0x10(%rax)
setge %al
jmp 0x68510
xorl %eax, %eax
testq %r15, %r15
js 0x68533
testb %al, %al
jne 0x68533
cmpq %r15, 0x8(%r14)
jle 0x68533
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 0x68549
leaq 0xad40d(%rip), %rax     # 0x115950
movq (%rax,%r15,8), %rax
jmp 0x68582
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x68568
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %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 0x6278d
// File: /workspace/github_c_makefile_star2_O2/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 0xb1653(%rip), %rcx     # 0x119c20
cmpb $0x1, (%rax,%rcx)
jne 0x68625
movq 0x18(%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x68625
movq %r15, %rcx
orq %r12, %rcx
js 0x68625
cmpq $0x2, 0x10(%rax)
jne 0x68625
movq (%rax), %rcx
cmpq %r12, (%rcx)
jle 0x68625
cmpq %r15, 0x8(%rcx)
jle 0x68625
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 0xad324(%rip), %rbp     # 0x115950
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0x6863c
movq (%rbp,%r12,8), %r13
jmp 0x68676
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6865b
movq %rbx, %rdi
callq 0x9c27
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 0x68686
movq (%rbp,%r15,8), %rax
jmp 0x686bf
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x686a5
movq %rbx, %rdi
callq 0x9c27
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %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 0x6278d
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %r15
movzbl (%rsi), %eax
leaq 0xb1507(%rip), %rcx     # 0x119c20
cmpb $0x1, (%rax,%rcx)
jne 0x68771
movq 0x18(%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x68736
cmpq $0x2, 0x10(%rax)
setge %al
jmp 0x68738
xorl %eax, %eax
testq %r12, %r12
js 0x68771
testb %al, %al
jne 0x68771
cmpq %r12, 0x8(%r14)
jle 0x68771
testb $0x2, 0x6(%r14)
jne 0x687ee
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq *0x28(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0x68787
leaq 0xad1cf(%rip), %rax     # 0x115950
movq (%rax,%r12,8), %rax
jmp 0x687c0
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0x687a6
movq %r15, %rdi
callq 0x9c27
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r12, 0x8(%rax)
movq 0x718(%r15), %rsi
movq %r14, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rbx, 0x8(%rax)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x627c1
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ecba
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: vector_set_p_piip
static s7_pointer vector_set_p_piip(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_pointer p)
                {
                    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_set(sc, set_elist_4(sc, v, make_integer(sc, i1), make_integer(sc, i2), p)));

                    if (is_typed_vector(v))
                        return(typed_vector_setter(sc, v, i2 + (i1 * vector_offset(v, 0)), p));

                    vector_setter(v)(sc, v, i2 + (i1 * vector_offset(v, 0)), p);
                    return(p);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rsi), %eax
leaq 0xb13f5(%rip), %rcx     # 0x119c20
cmpb $0x1, (%rax,%rcx)
jne 0x68896
movq 0x18(%r15), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x68896
movq %r12, %rcx
orq %r13, %rcx
js 0x68896
cmpq $0x2, 0x10(%rax)
jne 0x68896
movq (%rax), %rcx
cmpq %r13, (%rcx)
jle 0x68896
cmpq %r12, 0x8(%rcx)
jle 0x68896
testb $0x2, 0x6(%r15)
jne 0x6897a
movq 0x18(%rax), %rax
imulq (%rax), %r13
addq %r12, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r8, %rcx
movq %r8, %rbx
callq *0x28(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xad0b3(%rip), %rbx     # 0x115950
cmpq $0x7ff, %r13            # imm = 0x7FF
ja 0x688ac
movq (%rbx,%r13,8), %rbp
jmp 0x688ec
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x688d1
movq %r14, %rdi
movq %r8, %rbp
callq 0x9c27
movq %rbp, %r8
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbp
movq $0xb, (%rbp)
movq %r13, 0x8(%rbp)
cmpq $0x7ff, %r12            # imm = 0x7FF
ja 0x688fb
movq (%rbx,%r12,8), %rax
jmp 0x6893a
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x68920
movq %r14, %rdi
movq %r8, %rbx
callq 0x9c27
movq %rbx, %r8
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r12, 0x8(%rax)
movq 0x6f0(%r14), %rcx
movq %r15, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rbp, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %r8, 0x8(%rax)
movq 0x6f0(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x627c1
movq 0x18(%rax), %rax
imulq (%rax), %r13
addq %r12, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r8, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ecba
// File: /workspace/github_c_makefile_star2_O2/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 0x689c8
cmpq %rdx, 0x8(%rbx)
jle 0x689c8
movq 0x20(%rbx), %rax
movq %rbx, %rsi
popq %rbx
jmpq *%rax
movq 0x1660(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xacf86(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
testq %rdx, %rdx
leaq 0xb1052(%rip), %rdx     # 0x119a48
leaq 0xb1043(%rip), %r8      # 0x119a40
cmovsq %rdx, %r8
movq (%r8), %r8
movq %rax, %rdx
callq 0xcb8f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0x68a35
cmpq %rdx, 0x8(%rsi)
jle 0x68a35
movq 0x10(%rsi), %rax
movq %rbx, (%rax,%rdx,8)
jmp 0x68a79
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xacf19(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
testq %rdx, %rdx
leaq 0xb0fe5(%rip), %rdx     # 0x119a48
leaq 0xb0fd6(%rip), %r8      # 0x119a40
cmovsq %rdx, %r8
movq (%r8), %r8
movq %rax, %rdx
callq 0xcb8f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: 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 0xb1189(%rip), %rcx     # 0x119c20
cmpb $0x1, (%rax,%rcx)
jne 0x68ae4
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x68ab1
cmpq $0x2, 0x10(%rax)
jge 0x68ae4
movq (%rsi), %rax
btl $0x18, %eax
jb 0x68b08
cmpb $0xb, (%rdx)
jne 0x68ae4
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
js 0x68b3e
cmpq 0x8(%rsi), %rdx
jge 0x68b3e
btq $0x31, %rax
jb 0x68b83
movq %rbx, %rcx
callq *0x28(%rsi)
movq %rbx, %rax
popq %rbx
retq
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 0x627c1
movq 0xb0e59(%rip), %rax     # 0x119968
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), %rsi
popq %rbx
jmp 0x972b
testq %rdx, %rdx
movq 0x1668(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xace0d(%rip), %rax     # 0x115960
movq 0x1f00(%rdi), %rcx
movq %rdx, 0x8(%rcx)
movq 0x1f00(%rdi), %rcx
leaq 0xb0edc(%rip), %rdx     # 0x119a48
leaq 0xb0ecd(%rip), %r8      # 0x119a40
cmovsq %rdx, %r8
movq (%r8), %r8
movq %rax, %rdx
popq %rbx
jmp 0xcb8f
movq %rbx, %rcx
popq %rbx
jmp 0x2ecba
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: list_ref_p_pi_direct
static s7_pointer list_ref_p_pi_direct(s7_scheme *sc, s7_pointer p1, s7_int i1)
                {
                    s7_pointer p;
                    s7_int i;
                    if ((i1 < 0) || (i1 > sc->max_list_length))
                        out_of_range(sc, sc->list_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    for (i = 0, p = p1; ((is_pair(p)) && (i < i1)); i++, p = cdr(p));
                    if (!is_pair(p))
                    {
                        if (type(p) == T_NIL)
                            out_of_range(sc, sc->list_ref_symbol, small_int(2), wrap_integer1(sc, i1), its_too_large_string);
                        else simple_wrong_type_argument_with_type(sc, sc->list_ref_symbol, p1, a_proper_list_string);
                    }
                    return(car(p));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x68c4d
cmpq %r15, 0x2b0(%rbx)
jge 0x68c91
testq %r15, %r15
movq 0x1258(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xaccfe(%rip), %rdx     # 0x115960
movq 0x1f00(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x1f00(%rbx), %rcx
leaq 0xb0dcd(%rip), %rax     # 0x119a48
leaq 0xb0dbe(%rip), %rdi     # 0x119a40
cmovsq %rax, %rdi
movq (%rdi), %r8
movq %rbx, %rdi
callq 0xcb8f
xorl %eax, %eax
movq %r14, %r12
movb (%r12), %cl
cmpb $0x1, %cl
jne 0x68cae
cmpq %r15, %rax
jge 0x68cae
incq %rax
movq 0x10(%r12), %r12
jmp 0x68c96
cmpb $0x1, %cl
je 0x68d06
movq 0x1258(%rbx), %rax
movq 0x8(%rax), %rsi
cmpb $0x2, %cl
jne 0x68ced
movq 0xacc96(%rip), %rdx     # 0x115960
movq 0x1f00(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x1f00(%rbx), %rcx
movq 0xb0d5d(%rip), %r8      # 0x119a40
movq %rbx, %rdi
callq 0xcb8f
jmp 0x68d06
movq 0x140(%rbx), %rcx
movq 0xb8f1d(%rip), %r8      # 0x121c18
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd456
movq 0x8(%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq