LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: memq_chooser
static s7_pointer memq_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if ((is_proper_quote(sc, caddr(expr))) &&
                            (is_pair(cadr(caddr(expr)))))
                    {
                        s7_int len;
                        len = s7_list_length(sc, cadr(caddr(expr)));
                        if (len > 0)
                        {
                            if (len == 2)
                                return(sc->memq_2);
                            if ((len % 4) == 0)
                                return(sc->memq_4);
                            if ((len % 3) == 0)
                                return(sc->memq_3);
                            return(sc->memq_any);
                        }
                    }
                    return(f);
                }

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xf6a10
testb $0x1, %al
jne 0x1d7c34
jmp 0x1d7d04
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1d7d04
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x31900
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jle 0x1d7d02
cmpq $0x2, (%rsp)
jne 0x1d7ca1
movq 0x28(%rsp), %rax
movq 0x1bd0(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d7d0e
movq (%rsp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x1d7cc8
movq 0x28(%rsp), %rax
movq 0x1be0(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d7d0e
movq (%rsp), %rax
movl $0x3, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x1d7cef
movq 0x28(%rsp), %rax
movq 0x1bd8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d7d0e
movq 0x28(%rsp), %rax
movq 0x1be8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d7d0e
jmp 0x1d7d04
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_memq_3
static s7_pointer g_memq_3(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer x, obj;
                    x = cadr(args);
                    obj = car(args);
                    while (true)
                    {
                        if (obj == car(x)) return(x);
                        x = cdr(x);
                        if (obj == car(x)) return(x);
                        x = cdr(x);
                        if (obj == car(x)) return(x);
                        x = cdr(x);
                        if (!is_pair(x)) return(sc->F);
                    }
                    return(sc->F);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7d69
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7df0
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7d93
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7df0
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7dbd
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7df0
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d7deb
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7df0
jmp 0x1d7d4a
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_memq_4
static s7_pointer g_memq_4(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer x, obj;
                    x = cadr(args);
                    obj = car(args);
                    while (true)
                    {
                        LOOP_4(if (obj == car(x)) return(x); x = cdr(x));
                        if (!is_pair(x)) return(sc->F);
                    }
                    return(sc->F);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x1d7e2c
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7e4b
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7eff
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7e78
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7eff
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7ea2
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7eff
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7ecc
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7eff
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d7efa
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d7eff
jmp 0x1d7e2a
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_memq_any
static s7_pointer g_memq_any(s7_scheme *sc, s7_pointer args)
                {
                    /* no circular list check needed in this case */
                    s7_pointer x, obj;
                    x = cadr(args);
                    obj = car(args);
                    while (true)
                    {
                        LOOP_4(if (obj == car(x)) return(x); x = cdr(x); if (!is_pair(x)) return(sc->F));
                    }
                    return(sc->F);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x1d7f3c
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7f5b
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d8077
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d7f8c
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d8077
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7fab
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d8077
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d7fdc
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d8077
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d7ff8
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d8077
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d8026
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d8077
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d8042
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d8077
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d8070
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d8077
jmp 0x1d8072
jmp 0x1d7f3a
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: tree_set_memq_chooser
static s7_pointer tree_set_memq_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
    {
        if ((is_proper_quote(sc, cadr(expr))) &&   /* not (tree-set-memq (quote) ... */
            (is_pair(cadadr(expr))))
                {
                s7_pointer p;
                for (p = cadadr(expr); is_pair(p); p = cdr(p))
                if (!is_symbol(car(p)))
                return(f);
                return(sc->tree_set_memq_syms); /* this is tree_set_memq_1 */
                }
                return(f);
                }

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xf6a10
testb $0x1, %al
jne 0x1d80c0
jmp 0x1d8141
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1d8141
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1d812e
movq (%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x1d811e
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d814b
jmp 0x1d8120
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x1d80f6
movq 0x28(%rsp), %rax
movq 0x1bf0(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d814b
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_read_line_uncopied
static s7_pointer g_read_line_uncopied(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer port;
        bool with_eol = false;
        port = car(args);
        if (!is_input_port(port))
            return(g_read_line(sc, args));
        if (is_not_null(cdr(args)))
            with_eol = (cadr(args) != sc->F);
        return(port_read_line(port)(sc, port, with_eol, false));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movb $0x0, 0x7(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x1d81a4
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6d060
movq %rax, 0x20(%rsp)
jmp 0x1d820b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x1d81dd
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x38(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movb 0x7(%rsp), %dl
xorl %ecx, %ecx
andb $0x1, %dl
movzbl %dl, %edx
callq *%rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: inlet_chooser
static s7_pointer inlet_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
    {
        if (!ops) return(f);
        if ((args > 0) &&
                ((args % 2) == 0))
        {
            s7_pointer p;
            for (p = cdr(expr); is_pair(p); p = cddr(p))
            {
                s7_pointer sym;
                if (!is_proper_quote(sc, car(p)))             /* 'abs etc, but tricky: ':abs */
                    return(f);
                sym = cadar(p);
                if ((!is_symbol(sym)) ||
                        (is_possibly_constant(sym)) ||            /* define-constant etc */
                        (is_syntactic_symbol(sym))  ||            /* (inlet 'if 3) */
                        ((is_slot(global_slot(sym))) &&
                         (is_syntactic(slot_value(global_slot(sym))))) ||
                        (sym == sc->let_ref_fallback_symbol) ||
                        (sym == sc->let_set_fallback_symbol))
                    return(f);
            }
            return(sc->simple_inlet);
        }
        return(f);
    }

// Assembly:
subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq %rcx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x1d8296
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1d83d1
cmpl $0x0, 0x2c(%rsp)
jle 0x1d83c7
movl 0x2c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1d83c7
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1d83b4
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xf6a10
testb $0x1, %al
jne 0x1d82fb
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1d83d1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1d838f
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1d838f
movq 0x8(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x20a, %eax            # imm = 0x20A
je 0x1d838f
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x1d8369
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x1d838f
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x1228(%rcx), %rax
je 0x1d838f
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x1238(%rcx), %rax
jne 0x1d839b
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1d83d1
jmp 0x1d839d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1d82c4
movq 0x38(%rsp), %rax
movq 0x1c00(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x1d83d1
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: let_ref_chooser
static s7_pointer let_ref_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
    {
        if ((!ops) || (!is_global(sc->let_ref_symbol))) return(f);

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

// Assembly:
movb %r8b, %al
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq %rcx, -0x28(%rsp)
andb $0x1, %al
movb %al, -0x29(%rsp)
testb $0x1, -0x29(%rsp)
je 0x1d86de
movq -0x10(%rsp), %rax
movq 0x1230(%rax), %rax
movq (%rax), %rax
andq $0x10000, %rax          # imm = 0x10000
cmpq $0x0, %rax
jne 0x1d86ed
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d87e9
movq -0x28(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x33, %eax
jne 0x1d87df
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0xda0(%rcx), %rax
jne 0x1d87dd
movq -0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1d87dd
movq -0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0x1d87dd
movq -0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1d87dd
movq -0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzwl 0x6(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1d87dd
jmp 0x1d879a
movq -0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
andq $-0x40001, %rcx         # imm = 0xFFFBFFFF
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq 0x1c08(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d87e9
jmp 0x1d87df
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: let_set_chooser
static s7_pointer let_set_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
    {
        if ((!ops) || (!is_global(sc->let_set_symbol))) return(f);
        if (optimize_op(expr) == HOP_SAFE_C_opSq_CS)
        {
            s7_pointer arg1, arg2, arg3;
            arg1 = cadr(expr);
            arg2 = caddr(expr);
            arg3 = cadddr(expr);
            if ((car(arg1) == sc->cdr_symbol) &&
                    (car(arg2) == sc->quote_symbol) &&
                    (is_symbol(cadr(arg2))) &&
                    (!is_possibly_constant(cadr(arg2))) &&
                    (!is_possibly_constant(arg3)))
                return(sc->lint_let_set);
        }
        return(f);
    }

// Assembly:
movb %r8b, %al
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq %rcx, -0x28(%rsp)
andb $0x1, %al
movb %al, -0x29(%rsp)
testb $0x1, -0x29(%rsp)
je 0x1d882e
movq -0x10(%rsp), %rax
movq 0x1240(%rax), %rax
movq (%rax), %rax
andq $0x10000, %rax          # imm = 0x10000
cmpq $0x0, %rax
jne 0x1d883d
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d891d
movq -0x28(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x6b, %eax
jne 0x1d8913
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rsp)
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0xda0(%rcx), %rax
jne 0x1d8911
movq -0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0x1d8911
movq -0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1d8911
movq -0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzwl 0x6(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1d8911
movq -0x48(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1d8911
movq -0x10(%rsp), %rax
movq 0x1c10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d891d
jmp 0x1d8913
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: argument_type
static s7_pointer argument_type(s7_scheme *sc, s7_pointer arg1)
                {
                    if (is_pair(arg1))
                    {
                        if (car(arg1) == sc->quote_symbol)
                            return(s7_type_of(sc, cadr(arg1)));

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1d8fd6
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0x1d8f47
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x46b00
movq %rax, 0x20(%rsp)
jmp 0x1d9004
movq 0x10(%rsp), %rdi
callq 0x182250
testb $0x1, %al
jne 0x1d8f57
jmp 0x1d8fd4
movq 0x10(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x2, %eax
jl 0x1d8fd4
movq 0x10(%rsp), %rax
movzwl 0x4(%rax), %eax
cmpl $0x9e, %eax
jge 0x1d8fd4
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0x1d8fd4
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1d8fd2
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1d8fd2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1d8fd2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1d9004
jmp 0x1d8fd4
jmp 0x1d8ffb
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x1d8ff9
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x46b00
movq %rax, 0x20(%rsp)
jmp 0x1d9004
jmp 0x1d8ffb
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: ref_check_index
static inline s7_int ref_check_index(s7_scheme *sc, s7_pointer v, s7_int i)
                {
                    /* according to valgrind, it is faster to split out the bounds check */
                    if ((i < 0) || (i >= vector_length(v)))
                        out_of_range(sc, sc->float_vector_ref_symbol, small_int(2), wrap_integer1(sc, i), (i < 0) ? its_negative_string : its_too_large_string);
                    return(i);
                }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jl 0x1d965b
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x1d96da
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0xef0(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x3ce0f(%rip), %rax     # 0x216490
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x12430
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jge 0x1d96b0
movq 0x40ecf(%rip), %rax     # 0x21a578
movq %rax, 0x8(%rsp)
jmp 0x1d96bc
movq 0x40eb9(%rip), %rax     # 0x21a570
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r8
callq 0x13880
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: c_rem_int
static inline s7_int c_rem_int(s7_scheme *sc, s7_int x, s7_int y)
    {
        if (y == 0)
            division_by_zero_error(sc, sc->remainder_symbol, set_elist_2(sc, wrap_integer1(sc, x), wrap_integer2(sc, y)));
        if ((y == 1) || (y == -1))   /* (remainder most-negative-fixnum -1) will segfault with arithmetic exception */
            return(0);
        return(x % y);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x1d9837
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x1470(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x12430
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1721c0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xb830
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x123b0
cmpq $0x1, 0x28(%rsp)
je 0x1d9847
cmpq $-0x1, 0x28(%rsp)
jne 0x1d9852
movq $0x0, 0x40(%rsp)
jmp 0x1d9863
movq 0x30(%rsp), %rax
cqto
idivq 0x28(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: lt_out_y
static bool lt_out_y(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, y))
            return(find_and_apply_method(sc, find_let(sc, y), sc->lt_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->lt_symbol, 2, y, T_REAL);
        return(false);
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1da704
movq 0x98(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1da704
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x9a10
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rax
movq 0x12c0(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x98(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x98(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1da652
movq 0x98(%rsp), %rdi
callq 0xc670
movq 0x98(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdx
callq 0xd9f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
callq 0xc84f0
movq 0x98(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
jmp 0x1da824
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movq 0x12c0(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x2, 0x60(%rsp)
movq 0x60(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1da75d
movq 0x60(%rsp), %rcx
leaq 0x3bd31(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x1da7e0
jmp 0x1da75f
movq 0x98(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x98(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1da78c
movq 0x98(%rsp), %rdi
callq 0xc670
movq 0x98(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0xb, (%rax)
movq 0x60(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq 0x98(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x3fde1(%rip), %r9      # 0x21a5f8
callq 0xc560
movb $0x0, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: lt_out_x
static bool lt_out_x(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, x))
            return(find_and_apply_method(sc, find_let(sc, x), sc->lt_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->lt_symbol, 1, x, T_REAL);
        return(false);
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1da9e4
movq 0x98(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1da9e4
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x9a10
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rax
movq 0x12c0(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x98(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x98(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1da932
movq 0x98(%rsp), %rdi
callq 0xc670
movq 0x98(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdx
callq 0xd9f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
callq 0xc84f0
movq 0x98(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
jmp 0x1dab04
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movq 0x12c0(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x1, 0x60(%rsp)
movq 0x60(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1daa3d
movq 0x60(%rsp), %rcx
leaq 0x3ba51(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x1daac0
jmp 0x1daa3f
movq 0x98(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x98(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1daa6c
movq 0x98(%rsp), %rdi
callq 0xc670
movq 0x98(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0xb, (%rax)
movq 0x60(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x3fb01(%rip), %r9      # 0x21a5f8
callq 0xc560
movb $0x0, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: geq_out_y
static bool geq_out_y(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, y))
            return(find_and_apply_method(sc, find_let(sc, y), sc->geq_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->geq_symbol, 2, y, T_REAL);
        return(false);
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1dacc4
movq 0x98(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1dacc4
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x9a10
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rax
movq 0xf48(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x98(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x98(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1dac12
movq 0x98(%rsp), %rdi
callq 0xc670
movq 0x98(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdx
callq 0xd9f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
callq 0xc84f0
movq 0x98(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
jmp 0x1dade4
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movq 0xf48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x2, 0x60(%rsp)
movq 0x60(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1dad1d
movq 0x60(%rsp), %rcx
leaq 0x3b771(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x1dada0
jmp 0x1dad1f
movq 0x98(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x98(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1dad4c
movq 0x98(%rsp), %rdi
callq 0xc670
movq 0x98(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0xb, (%rax)
movq 0x60(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq 0x98(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x3f821(%rip), %r9      # 0x21a5f8
callq 0xc560
movb $0x0, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: geq_out_x
static bool geq_out_x(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, x))
            return(find_and_apply_method(sc, find_let(sc, x), sc->geq_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->geq_symbol, 1, x, T_REAL);
        return(false);
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1dafa4
movq 0x98(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1dafa4
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x9a10
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rax
movq 0xf48(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x98(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x98(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1daef2
movq 0x98(%rsp), %rdi
callq 0xc670
movq 0x98(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdx
callq 0xd9f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
callq 0xc84f0
movq 0x98(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
jmp 0x1db0c4
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movq 0xf48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x1, 0x60(%rsp)
movq 0x60(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1daffd
movq 0x60(%rsp), %rcx
leaq 0x3b491(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x1db080
jmp 0x1dafff
movq 0x98(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x98(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1db02c
movq 0x98(%rsp), %rdi
callq 0xc670
movq 0x98(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0xb, (%rax)
movq 0x60(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x3f541(%rip), %r9      # 0x21a5f8
callq 0xc560
movb $0x0, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: check_char2_args
static inline void check_char2_args(s7_scheme *sc, s7_pointer caller, s7_pointer p1, s7_pointer p2)
    {
        if (!s7_is_character(p1))
            simple_wrong_type_argument(sc, caller, p1, T_CHARACTER);
        if (!s7_is_character(p2))
            simple_wrong_type_argument(sc, caller, p2, T_CHARACTER);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x1db131
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x3f4a4(%rip), %r8      # 0x21a5d0
callq 0x14a60
movq 0x8(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x1db16a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x3f46b(%rip), %r8      # 0x21a5d0
callq 0x14a60
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: check_string2_args
static inline void check_string2_args(s7_scheme *sc, s7_pointer caller, s7_pointer p1, s7_pointer p2)
    {
        if (!is_string(p1))
            simple_wrong_type_argument(sc, caller, p1, T_STRING);
        if (!s7_is_string(p2))
            simple_wrong_type_argument(sc, caller, p2, T_STRING);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x1db1c0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x3f46d(%rip), %r8      # 0x21a628
callq 0x14a60
movq 0x8(%rsp), %rdi
callq 0x14460
testb $0x1, %al
jne 0x1db1f9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x3f434(%rip), %r8      # 0x21a628
callq 0x14a60
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: sl_integer_gt_0
static s7_pointer sl_integer_gt_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_integer(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_INTEGER));
                    if (s7_integer(val) <= 0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be positive", 18)));
                    return(val);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x1db253
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x3f3a1(%rip), %r8      # 0x21a5e8
callq 0x14a60
movq %rax, 0x30(%rsp)
jmp 0x1db2c1
movq 0x18(%rsp), %rdi
callq 0x10790
cmpq $0x0, %rax
jg 0x1db2b7
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18ebe(%rip), %rsi     # 0x1f414e
movl $0x12, %edx
callq 0xb880
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0x45240
movq %rax, 0x30(%rsp)
jmp 0x1db2c1
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: sl_real_geq_0
static s7_pointer sl_real_geq_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_real(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_REAL));
                    if (s7_real(val) < 0.0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be positive", 18)));
                    return(val);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11360
testb $0x1, %al
jne 0x1db393
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x3f271(%rip), %r8      # 0x21a5f8
callq 0x14a60
movq %rax, 0x30(%rsp)
jmp 0x1db407
movq 0x18(%rsp), %rdi
callq 0x128d0
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1db3fd
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18d78(%rip), %rsi     # 0x1f414e
movl $0x12, %edx
callq 0xb880
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0x45240
movq %rax, 0x30(%rsp)
jmp 0x1db407
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: sl_integer_geq_0
static s7_pointer sl_integer_geq_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_integer(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_INTEGER));
                    if (s7_integer(val) < 0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be non-negative", 18)));
                    return(val);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x1db473
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x3f181(%rip), %r8      # 0x21a5e8
callq 0x14a60
movq %rax, 0x30(%rsp)
jmp 0x1db4e1
movq 0x18(%rsp), %rdi
callq 0x10790
cmpq $0x0, %rax
jge 0x1db4d7
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18cc6(%rip), %rsi     # 0x1f4176
movl $0x12, %edx
callq 0xb880
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0x45240
movq %rax, 0x30(%rsp)
jmp 0x1db4e1
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: manage_directories
static void manage_directories(s7_scheme *sc, char *argv0) {
    progname = basename(argv0);
    s7_home = dirname(argv0);
    char *start_dir = NULL;
    // fprintf(stdout, "s7_home  : <%s> (DEBUG)\n", s7_home);
    switch (*s7_home) {
        case '.':
            // current dir or upper (..)
            if (*(s7_home + 1) == '.') {
                start_dir = concat(strdup(dirname(getcwd(NULL, 0))), s7_home + 2);
            } else {
                start_dir = concat(strdup(getcwd(NULL, 0)), s7_home + 1);
            }
            break;
        case '/':
            // absolute dir, nothing to do
            start_dir = strdup(s7_home);
            break;
        default:
            // relative dir
            start_dir = concat(getcwd(NULL, 0), s7_home);
            break;
    }
    s7_home = start_dir;
    s7_libs = concat(s7_home, "libs");
    atexit(clean_on_exit);
    /*
    fprintf(stdout, "progname : <%s>\n", progname);
    fprintf(stdout, "s7_home  : <%s>\n", s7_home);
    fprintf(stdout, "s7_libs  : <%s>\n", s7_libs);
    fprintf(stdout, "start_dir: <%s>\n", start_dir);
    */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9400
movq %rax, 0x49b69(%rip)     # 0x225428
movq 0x18(%rsp), %rdi
callq 0x9230
movq %rax, 0x49b48(%rip)     # 0x225418
movq $0x0, 0x10(%rsp)
movq 0x49b38(%rip), %rax     # 0x225418
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x2e, %eax
je 0x1db8fc
jmp 0x1db8ee
movl 0xc(%rsp), %eax
subl $0x2f, %eax
je 0x1db970
jmp 0x1db983
movq 0x49b15(%rip), %rax     # 0x225418
movsbl 0x1(%rax), %eax
cmpl $0x2e, %eax
jne 0x1db942
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x9280
movq %rax, %rdi
callq 0x9230
movq %rax, %rdi
callq 0x96a0
movq %rax, %rdi
movq 0x49ae6(%rip), %rsi     # 0x225418
addq $0x2, %rsi
callq 0x1dbbe0
movq %rax, 0x10(%rsp)
jmp 0x1db96e
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x9280
movq %rax, %rdi
callq 0x96a0
movq %rax, %rdi
movq 0x49ab8(%rip), %rsi     # 0x225418
addq $0x1, %rsi
callq 0x1dbbe0
movq %rax, 0x10(%rsp)
jmp 0x1db9a3
movq 0x49aa1(%rip), %rdi     # 0x225418
callq 0x96a0
movq %rax, 0x10(%rsp)
jmp 0x1db9a3
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x9280
movq %rax, %rdi
movq 0x49a7f(%rip), %rsi     # 0x225418
callq 0x1dbbe0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x49a69(%rip)     # 0x225418
movq 0x49a62(%rip), %rdi     # 0x225418
leaq 0x18906(%rip), %rsi     # 0x1f42c3
callq 0x1dbbe0
movq %rax, 0x49a57(%rip)     # 0x225420
leaq 0x4d0(%rip), %rdi       # 0x1dbea0
callq 0x1dc700
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: dohelp
static void dohelp(const int exit_code) {
    fprintf(stdout, "%s [-h|-v|-qb] [-L dir-lib]\n", progname);
    fprintf(stdout, "  -h: show this text and exits\n");
    fprintf(stdout, "  -v: show VERSION and exits\n");
    fprintf(stdout, "  -q: quiet, suppress some messages\n");
    fprintf(stdout, "  -b: batch, executes files and quit, implies -q\n");
    fprintf(stdout, "  -L dir-lib: add dir-lib to *load-path*\n");
    exit (exit_code);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movq 0x395e4(%rip), %rax     # 0x214fd0
movq (%rax), %rdi
movq 0x49a32(%rip), %rdx     # 0x225428
leaq 0x188cb(%rip), %rsi     # 0x1f42c8
movb $0x0, %al
callq 0x9390
movq 0x395c5(%rip), %rax     # 0x214fd0
movq (%rax), %rdi
leaq 0x188d0(%rip), %rsi     # 0x1f42e5
movb $0x0, %al
callq 0x9390
movq 0x395ad(%rip), %rax     # 0x214fd0
movq (%rax), %rdi
leaq 0x188d8(%rip), %rsi     # 0x1f4305
movb $0x0, %al
callq 0x9390
movq 0x39595(%rip), %rax     # 0x214fd0
movq (%rax), %rdi
leaq 0x188de(%rip), %rsi     # 0x1f4323
movb $0x0, %al
callq 0x9390
movq 0x3957d(%rip), %rax     # 0x214fd0
movq (%rax), %rdi
leaq 0x188eb(%rip), %rsi     # 0x1f4348
movb $0x0, %al
callq 0x9390
movq 0x39565(%rip), %rax     # 0x214fd0
movq (%rax), %rdi
leaq 0x18905(%rip), %rsi     # 0x1f437a
movb $0x0, %al
callq 0x9390
movl 0x4(%rsp), %edi
callq 0x9650
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: is_read_dir
static bool is_read_dir(char *dir_name) {
    struct stat statbuf;
    if (stat(dir_name, &statbuf) != 0) {
        return false;
    } else if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
        return false;
    } else {
        return true;
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x93d0
cmpl $0x0, %eax
je 0x1dbae0
movb $0x0, 0xa7(%rsp)
jmp 0x1dbb02
movl 0x20(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x1dbafa
movb $0x0, 0xa7(%rsp)
jmp 0x1dbb02
movb $0x1, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: add_lib_dir
static void add_lib_dir(s7_scheme *sc, const char *lib_dir) {
    sprintf(scm_code_buffer,
            "(set! *load-path* (cons \"%s\" *load-path*))",
            lib_dir);
    s7_eval_c_string(sc, scm_code_buffer);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdx
leaq 0x498f6(%rip), %rdi     # 0x225430
leaq 0x18863(%rip), %rsi     # 0x1f43a4
movb $0x0, %al
callq 0x9640
movq 0x10(%rsp), %rdi
leaq 0x498dc(%rip), %rsi     # 0x225430
callq 0x2b910
addq $0x18, %rsp
retq
nop