LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: let_setter
static s7_pointer let_setter(s7_scheme *sc, s7_pointer e, s7_int loc, s7_pointer val)
                {
                    /* loc is irrelevant here
                     * val has to be of the form (cons symbol value)
                     * if symbol is already in e, its value is changed, otherwise a new slot is added to e
                     */
                    if (is_pair(val))
                    {
                        s7_pointer sym;
                        sym = car(val);
                        if (is_symbol(sym))
                        {
                            s7_pointer slot;
                            slot = slot_in_let(sc, e, sym);
                            if (is_slot(slot))
                                checked_slot_set_value(sc, slot, cdr(val));
                            else make_slot_1(sc, e, sym, cdr(val));
                            return(cdr(val));
                        }
                    }
                    set_car(sc->elist_3, wrap_string(sc, "~S: ~S is not (cons symbol value)", 33));
                    set_caddr(sc->elist_3, val);
                    return(s7_error(sc, sc->wrong_type_arg_symbol, sc->elist_3));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
cmpb $0x1, (%rcx)
jne 0xa1282
movq 0x8(%r14), %rdx
movb (%rdx), %bpl
cmpb $0xa, %bpl
jne 0xa127c
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0xa11f1
cmpq %rdx, 0x8(%r15)
je 0xa11f8
movq 0x18(%r15), %r15
jmp 0xa11e0
movq 0x128(%rbx), %r15
cmpb $0x20, (%r15)
movq 0x10(%r14), %rcx
jne 0xa1217
movq (%r15), %rax
btl $0x12, %eax
jb 0xa1221
btl $0x18, %eax
jb 0xa1235
movq %rcx, 0x10(%r15)
jmp 0xa1278
movq %rbx, %rdi
callq 0xb169
jmp 0xa1278
movq %rbx, %rdi
movq %r15, %rsi
movq %rcx, %rdx
callq 0x953ff
movq %rax, 0x10(%r15)
jmp 0xa1278
movq 0xb172c(%rip), %rax     # 0x152968
movq 0x1240(%rbx), %rcx
movq 0x8(%r15), %rdx
movq 0x6e8(%rbx), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x6e8(%rbx), %rdx
movq 0xea8(%rbx), %rsi
movq %rbx, %rdi
callq 0x3b366
movq 0x10(%r14), %r15
cmpb $0xa, %bpl
je 0xa12e9
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x7f0e4(%rip), %rcx     # 0x12038a
movq %rcx, 0x10(%rax)
movq $0x21, 0x8(%rax)
movq 0x6e8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e8(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x1940(%rbx), %r15
movq 0x6e8(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b366
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: copy_c_object
static s7_pointer copy_c_object(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer obj;
                    obj = car(args);
                    check_method(sc, obj, sc->copy_symbol, args);
                    if (c_object_copy(sc, obj))
                        return((*(c_object_copy(sc, obj)))(sc, args));
                    eval_error(sc, "attempt to copy ~S?", 19, obj);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movb $0x1, %bpl
testb $0x40, 0x3(%r14)
je 0xa1af6
cmpb $0x1, 0x24c(%rbx)
jne 0xa1af6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq 0xe20(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0xa1af6
cmpb $0x1, (%r15)
jne 0xa1ba2
movq %rax, 0x8(%rsp)
movq %r15, 0x4c8(%rbx)
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0xa1a32
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, (%rsp)
movq %rax, 0x4e8(%rbx)
movq %r15, 0x10(%rsp)
movq 0x10(%r15), %rbp
cmpb $0x1, (%rbp)
jne 0xa1ace
movq (%rsp), %r13
movq 0x8(%rbp), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r15
cmpq 0x98(%rbx), %rax
ja 0xa1a98
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x10(%r13)
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
movq %rax, %r13
je 0xa1a75
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %rax
movq (%rsp), %rdx
jmp 0xa1ba9
testb %bpl, %bpl
je 0xa1b90
movq 0x8d8(%rbx), %rax
movq 0x8(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0xa1b2d
movq %rbx, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x1918(%rbx), %r12
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x7e7d0(%rip), %rcx     # 0x120328
movq %rcx, 0x10(%rax)
movq $0x13, 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 %r12, %rsi
callq 0x3b366
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbd41
movq %rax, %r12
xorl %ebp, %ebp
jmp 0xa1af6
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: rng_copy
static s7_pointer rng_copy(s7_scheme *sc, s7_pointer args)
    {
#if WITH_GMP
        return(sc->F); /* I can't find a way to copy a gmp random generator */
#else
        s7_pointer obj;
        obj = car(args);
        if (is_random_state(obj))
        {
            s7_pointer new_r;
            new_cell(sc, new_r, T_RANDOM_STATE);
            random_seed(new_r) = random_seed(obj);
            random_carry(new_r) = random_carry(obj);
            return(new_r);
        }
        return(sc->F);
#endif
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x24, (%r14)
jne 0xa1c16
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa1be7
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x24, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
jmp 0xa1c1d
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: make_hash_entry
static hash_entry_t *make_hash_entry(s7_scheme *sc, s7_pointer key, s7_pointer value, s7_int raw_hash)
                {
                    hash_entry_t *p;
                    p = (hash_entry_t *)mallocate_block(sc);
                    hash_entry_key(p) = key;
                    hash_entry_set_value(p, value);
                    hash_entry_set_raw_hash(p, raw_hash);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x838(%rdi)
jne 0xa2354
movl $0x2800, %edi           # imm = 0x2800
callq 0x9480
movq %rax, 0x838(%r12)
addq $0x28, %rax
movl $0xff, %ecx
movq %rax, -0x10(%rax)
movl $0x0, -0x20(%rax)
addq $0x28, %rax
decl %ecx
jne 0xa2332
movq $0x0, -0x10(%rax)
movl $0x0, -0x20(%rax)
movq 0x838(%r12), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x838(%r12)
movl $0x0, 0x8(%rax)
movq %r15, (%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: copy_tree_with_type
static s7_pointer copy_tree_with_type(s7_scheme *sc, s7_pointer tree)
    {
        /* if sc->safety > NO_SAFETY, '(1 2) is set immutable by the reader, but eval (in that safety case) calls
         *   copy_body on the incoming tree, so we have to preserve T_IMMUTABLE in that case.
         * if tree is something like (+ 1 (car '#1=(2 . #1#))), we have to see the quoted list and not copy it.
         */
#if WITH_GCC
#define COPY_TREE_WITH_TYPE(P) ({s7_pointer _p; _p = P; \
        cons_unchecked_with_type(sc, _p, (is_unquoted_pair(car(_p))) ? copy_tree_with_type(sc, car(_p)) : car(_p), \
                (is_unquoted_pair(cdr(_p))) ? copy_tree_with_type(sc, cdr(_p)) : cdr(_p));})
#else
#define COPY_TREE_WITH_TYPE(P) copy_tree_with_type(sc, P)
#endif

        return(cons_unchecked_with_type(sc, tree,
                    (is_unquoted_pair(car(tree))) ? COPY_TREE_WITH_TYPE(car(tree)) : car(tree),
                    (is_unquoted_pair(cdr(tree))) ? COPY_TREE_WITH_TYPE(cdr(tree)) : cdr(tree)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r12
cmpb $0x1, (%r12)
jne 0xa241b
movq 0x8(%r12), %r15
movq 0x17b0(%r14), %rax
cmpq %rax, %r15
je 0xa241b
cmpb $0x1, (%r15)
jne 0xa23cb
cmpq %rax, 0x8(%r15)
je 0xa23cb
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2386
movq %rax, %r15
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0xa23ed
movq 0x8(%rax), %rcx
cmpq 0x17b0(%r14), %rcx
je 0xa23ed
movq %r14, %rdi
movq %rax, %rsi
callq 0xa2386
movq 0x90(%r14), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%r14)
movq (%r12), %rdx
movq -0x8(%rcx), %r12
andl $0x12000ff, %edx        # imm = 0x12000FF
movq %rdx, (%r12)
movq %r15, 0x8(%r12)
movq %rax, 0x10(%r12)
movq 0x10(%rbx), %r13
cmpb $0x1, (%r13)
jne 0xa249d
movq 0x8(%r13), %r15
movq 0x17b0(%r14), %rax
cmpq %rax, %r15
je 0xa249d
cmpb $0x1, (%r15)
jne 0xa2450
cmpq %rax, 0x8(%r15)
je 0xa2450
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2386
movq %rax, %r15
movq 0x10(%r13), %rax
cmpb $0x1, (%rax)
jne 0xa2471
movq 0x8(%rax), %rcx
cmpq 0x17b0(%r14), %rcx
je 0xa2471
movq %r14, %rdi
movq %rax, %rsi
callq 0xa2386
movq 0x90(%r14), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%r14)
movq (%r13), %rdx
movq -0x8(%rcx), %r13
andl $0x12000ff, %edx        # imm = 0x12000FF
movq %rdx, (%r13)
movq %r15, 0x8(%r13)
movq %rax, 0x10(%r13)
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq (%rbx), %rcx
andl $0x12000ff, %ecx        # imm = 0x12000FF
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: copy_tree
static s7_pointer copy_tree(s7_scheme *sc, s7_pointer tree)
    {
#if WITH_GCC
#define COPY_TREE(P) ({s7_pointer _p; _p = P; \
        cons_unchecked(sc, (is_pair(car(_p))) ? copy_tree(sc, car(_p)) : car(_p), \
                (is_pair(cdr(_p))) ? copy_tree(sc, cdr(_p)) : cdr(_p));})
#else
#define COPY_TREE(P) copy_tree(sc, P)
#endif

        return(cons_unchecked(sc,
                    (is_pair(car(tree))) ? COPY_TREE(car(tree)) : car(tree),
                    (is_pair(cdr(tree))) ? COPY_TREE(cdr(tree)) : cdr(tree)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpb $0x1, (%r12)
jne 0xa2540
movq 0x8(%r12), %r15
cmpb $0x1, (%r15)
jne 0xa2503
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa24d1
movq %rax, %r15
movq 0x10(%r12), %rax
cmpb $0x1, (%rax)
jne 0xa2518
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa24d1
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %r12
movq $0x200001, (%r12)       # imm = 0x200001
movq %r15, 0x8(%r12)
movq %rax, 0x10(%r12)
movq 0x10(%r14), %r15
cmpb $0x1, (%r15)
jne 0xa259b
movq 0x8(%r15), %r14
cmpb $0x1, (%r14)
jne 0xa2562
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa24d1
movq %rax, %r14
movq 0x10(%r15), %rax
cmpb $0x1, (%rax)
jne 0xa2576
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa24d1
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rbx)
movq -0x8(%rcx), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r14, 0x8(%r15)
movq %rax, 0x10(%r15)
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: tree_len_1
static inline s7_int tree_len_1(s7_scheme *sc, s7_pointer p)
    {
        s7_int sum;
        for (sum = 0; is_pair(p); p = cdr(p))
        {
            s7_pointer cp;
            cp = car(p);
            if ((!is_pair(cp)) ||
                    (car(cp) == sc->quote_symbol))
                sum++;
            else
            {
                do {
                    s7_pointer ccp;
                    ccp = car(cp);
                    if ((!is_pair(ccp)) ||
                            (car(ccp) == sc->quote_symbol))
                        sum++;
                    else
                    {
                        do {
                            s7_pointer cccp;
                            cccp = car(ccp);
                            if ((!is_pair(cccp)) ||
                                    (car(cccp) == sc->quote_symbol))
                                sum++;
                            else sum += tree_len_1(sc, cccp);
                            ccp = cdr(ccp);
                        } while (is_pair(ccp));
                        if (!is_null(ccp)) sum++;
                    }
                    cp = cdr(cp);
                } while (is_pair(cp));
                if (!is_null(cp)) sum++;
            }
        }
        if (!is_null(p)) return(sum + 1);
        return(sum);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, (%rsi)
jne 0xa267f
xorl %r15d, %r15d
movq 0x8(%rbx), %r12
cmpb $0x1, (%r12)
jne 0xa266d
movq 0x17b0(%r14), %r13
cmpq %r13, 0x8(%r12)
je 0xa266d
movq 0x8(%r12), %rbp
cmpb $0x1, (%rbp)
jne 0xa264d
cmpq %r13, 0x8(%rbp)
je 0xa264d
movq 0x8(%rbp), %rsi
cmpb $0x1, (%rsi)
jne 0xa262f
cmpq %r13, 0x8(%rsi)
je 0xa262f
movq %r14, %rdi
callq 0xa25cc
addq %rax, %r15
jmp 0xa2632
incq %r15
movq 0x10(%rbp), %rbp
cmpb $0x1, (%rbp)
je 0xa2613
xorl %eax, %eax
cmpq 0x110(%r14), %rbp
setne %al
addq %rax, %r15
jmp 0xa2650
incq %r15
movq 0x10(%r12), %r12
cmpb $0x1, (%r12)
je 0xa2602
xorl %eax, %eax
cmpq 0x110(%r14), %r12
setne %al
addq %rax, %r15
jmp 0xa2670
incq %r15
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0xa25e9
jmp 0xa2682
xorl %r15d, %r15d
xorl %eax, %eax
cmpq 0x110(%r14), %rbx
setne %al
addq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: stacktrace_find_caller
static s7_pointer stacktrace_find_caller(s7_scheme *sc, s7_pointer e)
                {
                    if ((is_let(e)) && (e != sc->rootlet))
                    {
                        if (is_funclet(e))
                            return(funclet_function(e));
                        return(stacktrace_find_caller(sc, outlet(e)));
                    }
                    return(sc->F);
                }

// Assembly:
cmpb $0x1c, (%rsi)
jne 0xa26ba
cmpq %rsi, 0x150(%rdi)
je 0xa26ba
testb $0x20, 0x3(%rsi)
jne 0xa26c2
movq 0x10(%rsi), %rsi
jmp 0xa26a0
movq 0x120(%rdi), %rax
retq
movq 0x20(%rsi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: prepackaged_type_name
static s7_pointer prepackaged_type_name(s7_scheme *sc, s7_pointer x)
                {
                    s7_pointer p;
                    uint8_t typ;

                    if (has_active_methods(sc, x))
                    {
                        p = find_method(sc, find_let(sc, x), sc->class_name_symbol);
                        if (is_symbol(p))
                            return(symbol_name_cell(p));
                    }
                    typ = type(x);
                    switch (typ)
                    {
                        case T_C_OBJECT:    return(c_object_scheme_name(sc, x));
                        case T_INPUT_PORT:  return((is_file_port(x)) ? an_input_file_port_string : ((is_string_port(x)) ? an_input_string_port_string : an_input_port_string));
                        case T_OUTPUT_PORT: return((is_file_port(x)) ? an_output_file_port_string : ((is_string_port(x)) ? an_output_string_port_string : an_output_port_string));
                        default:
                                            p = prepackaged_type_names[type(x)];
                                            if (is_string(p)) return(p);
                    }
                    return(wrap_string(sc, "unknown type!", 13));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testb $0x40, 0x3(%rsi)
je 0xa2ca0
cmpb $0x1, 0x24c(%rbx)
jne 0xa2ca0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9a55
movq 0x18e8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
cmpb $0xa, (%rax)
jne 0xa2ca0
movq 0x8(%rax), %rax
jmp 0xa2d60
movzbl (%r14), %eax
cmpl $0x23, %eax
je 0xa2ce9
cmpl $0x22, %eax
je 0xa2ccb
cmpl $0x14, %eax
jne 0xa2d0e
movq 0x8d8(%rbx), %rax
movq 0x8(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
jmp 0xa2d60
movq 0x8(%r14), %rax
movl 0x4(%rax), %eax
testl %eax, %eax
je 0xa2d50
cmpl $0x1, %eax
leaq 0xb83a8(%rip), %rax     # 0x15b088
leaq 0xb75e1(%rip), %rcx     # 0x15a2c8
jmp 0xa2d05
movq 0x8(%r14), %rax
movl 0x4(%rax), %eax
testl %eax, %eax
je 0xa2d59
cmpl $0x1, %eax
leaq 0xb837a(%rip), %rax     # 0x15b078
leaq 0xafefb(%rip), %rcx     # 0x152c00
cmoveq %rax, %rcx
movq (%rcx), %rax
jmp 0xa2d60
leaq 0xafd4b(%rip), %rcx     # 0x152a60
movq (%rcx,%rax,8), %rax
cmpb $0x13, (%rax)
je 0xa2d60
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x7d756(%rip), %rcx     # 0x120498
movq %rcx, 0x10(%rax)
movq $0xd, 0x8(%rax)
jmp 0xa2d60
movq 0xb8329(%rip), %rax     # 0x15b080
jmp 0xa2d60
movq 0xb8310(%rip), %rax     # 0x15b070
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: type_name
static const char *type_name(s7_scheme *sc, s7_pointer arg, article_t article)
                {
                    switch (unchecked_type(arg))
                    {
                        case T_C_OBJECT:
                            return(make_type_name(sc, string_value(c_object_scheme_name(sc, arg)), article));

                        case T_INPUT_PORT:
                            return(make_type_name(sc, (is_file_port(arg)) ? "input file port" : ((is_string_port(arg)) ? "input string port" : "input port"), article));

                        case T_OUTPUT_PORT:
                            return(make_type_name(sc, (is_file_port(arg)) ? "output file port" : ((is_string_port(arg)) ? "output string port" : "output port"), article));

                        case T_LET:
                            if (has_active_methods(sc, arg))
                            {
                                s7_pointer class_name;
                                class_name = find_method(sc, arg, sc->class_name_symbol);
                                if (is_symbol(class_name))
                                    return(make_type_name(sc, symbol_name(class_name), article));
                            }

                        default:
                            {
                                const char *str;
                                str = type_name_from_type(unchecked_type(arg), article);
                                if (str) return(str);
                            }
                    }
                    return("messed up object");
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rsi), %eax
cmpl $0x21, %eax
jg 0xa2dd6
cmpl $0x14, %eax
je 0xa2e2e
cmpl $0x1c, %eax
jne 0xa2e07
testb $0x40, 0x3(%r15)
je 0xa2e07
cmpb $0x1, 0x24c(%r14)
jne 0xa2e07
movq 0x18e8(%r14), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x99ef
movq %rax, %rcx
movb (%rax), %bpl
cmpb $0xa, %bpl
jne 0xa2dce
movq 0x8(%rcx), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0xa0491
cmpb $0xa, %bpl
jne 0xa2e07
jmp 0xa2e23
cmpl $0x22, %eax
je 0xa2e47
cmpl $0x23, %eax
jne 0xa2e07
movq 0x8(%r15), %rax
movl 0x4(%rax), %eax
cmpl $0x1, %eax
leaq 0x80feb(%rip), %rcx     # 0x123ddc
leaq 0x73579(%rip), %rdx     # 0x116371
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x80fec(%rip), %rsi     # 0x123df1
jmp 0xa2e6c
movzbl (%r15), %edi
movl %ebx, %esi
callq 0x6133a
movq %rax, %rcx
testq %rax, %rax
leaq 0x7d687(%rip), %rax     # 0x1204a6
cmovneq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8d8(%r14), %rax
movq 0x8(%r15), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
jmp 0xa2e70
movq 0x8(%r15), %rax
movl 0x4(%rax), %eax
cmpl $0x1, %eax
leaq 0x73819(%rip), %rcx     # 0x116671
leaq 0x7359f(%rip), %rdx     # 0x1163fe
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x80f98(%rip), %rsi     # 0x123e04
cmovneq %rdx, %rsi
movq %r14, %rdi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa0491
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: lookup
static inline s7_pointer lookup(s7_scheme *sc, s7_pointer symbol) /* lookup_checked includes the unbound_variable call */
#endif
        {
            s7_pointer x;
            if (let_id(sc->envir) == symbol_id(symbol))
                return(slot_value(local_slot(symbol)));
            for (x = sc->envir; symbol_id(symbol) < let_id(x); x = outlet(x));
            if (let_id(x) == symbol_id(symbol))
                return(slot_value(local_slot(symbol)));
            for (; is_let(x); x = outlet(x))
            {
                s7_pointer y;
                for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                    if (slot_symbol(y) == symbol)
                        return(slot_value(y));
            }
            /* if (is_global(symbol)) fprintf(stderr, "%s in %s\n", DISPLAY(symbol), DISPLAY_80(sc->code)); */
            x = global_slot(symbol);
            if (is_slot(x)) return(slot_value(x));
#if WITH_GCC
            return(NULL); /* much faster than various alternatives */
#else
            return(unbound_variable(sc, symbol));
#endif
        }

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x20(%rsi), %rax
cmpq %rax, 0x18(%rcx)
je 0xa2ea6
movq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jge 0xa2ea1
movq 0x10(%rcx), %rcx
jmp 0xa2e92
cmpq %rax, %rdx
jne 0xa2eaf
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
retq
cmpb $0x1c, (%rcx)
jne 0xa2edd
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %dl
je 0xa2ed0
cmpq %rsi, 0x8(%rdi)
je 0xa2ecc
movq 0x18(%rdi), %rdi
jmp 0xa2eb8
movq 0x10(%rdi), %rax
testb %dl, %dl
je 0xa2ee8
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xa2eb4
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xa2eaa
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: find_autoload_name
static const char *find_autoload_name(s7_scheme *sc, s7_pointer symbol, bool *already_loaded, bool loading)
    {
        s7_int l = 0, lib, libs;
        const char *name;

        name = symbol_name(symbol);
        libs = sc->autoload_names_loc;

        for (lib = 0; lib < libs; lib++)
        {
            const char **names;
            s7_int u;
            u = sc->autoload_names_sizes[lib] - 1;
            names = sc->autoload_names[lib];

            while (true)
            {
                s7_int comp, pos;
                const char *this_name;
                if (u < l) break;
                pos = (l + u) / 2;
                this_name = names[pos * 2];
                comp = strcmp(this_name, name);
                if (comp == 0)
                {
                    *already_loaded = sc->autoloaded_already[lib][pos];
                    if (loading) sc->autoloaded_already[lib][pos] = true;
                    return(names[pos * 2 + 1]);             /* file name given func name */
                }
                if (comp < 0)
                    l = pos + 1;
                else u = pos - 1;
            }
        }
        return(NULL);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x2178(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
jle 0xa386b
movq 0x8(%rsi), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x2160(%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x2168(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
xorl %ebx, %ebx
movq 0x10(%rsp), %rax
movq (%rax,%rbx,8), %rbp
decq %rbp
movq 0x18(%rsp), %rax
movq (%rax,%rbx,8), %r15
cmpq %r14, %rbp
jge 0xa37cb
movl $0x6, %ecx
jmp 0xa383e
leaq (%r14,%rbp), %r12
movq %r12, %r13
shrq %r13
movq %r12, %rax
movabsq $0x1ffffffffffffffe, %rcx # imm = 0x1FFFFFFFFFFFFFFE
andq %rcx, %rax
movq (%r15,%rax,8), %rdi
movq 0x40(%rsp), %rsi
callq 0x9370
testl %eax, %eax
je 0xa3801
js 0xa3842
decq %r13
movq %r13, %rbp
jmp 0xa3848
movq 0x30(%rsp), %rax
movq 0x2170(%rax), %rax
movq (%rax,%rbx,8), %rax
movb (%rax,%r13), %cl
movq 0x38(%rsp), %rdx
movb %cl, (%rdx)
cmpb $0x0, 0xc(%rsp)
je 0xa3828
movb $0x1, (%rax,%r13)
shlq $0x3, %r12
orq $0x8, %r12
movq (%r15,%r12), %rax
movq %rax, 0x28(%rsp)
movl $0x1, %ecx
xorl %eax, %eax
jmp 0xa384c
incq %r13
movq %r13, %r14
xorl %ecx, %ecx
movb $0x1, %al
testl %ecx, %ecx
je 0xa37bf
cmpl $0x6, %ecx
je 0xa385d
testb %al, %al
je 0xa386f
incq %rbx
cmpq 0x20(%rsp), %rbx
jne 0xa37aa
xorl %eax, %eax
jmp 0xa3874
movq 0x28(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: loaded_library
static s7_pointer loaded_library(s7_scheme *sc, const char *file)
                {
                    s7_pointer p;
                    for (p = slot_value(global_slot(sc->libraries_symbol)); is_pair(p); p = cdr(p))
                        if (local_strcmp(file, string_value(caar(p))))
                            return(cdar(p));
                    return(sc->nil);
                }

// Assembly:
movq 0x1250(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa38c6
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rdx
movq 0x10(%rdx), %rdx
xorl %r8d, %r8d
movb (%rsi,%r8), %r9b
movb (%rdx,%r8), %r10b
testb %r9b, %r9b
je 0xa38bb
incq %r8
cmpb %r10b, %r9b
je 0xa38a6
cmpb %r10b, %r9b
jne 0xa388e
addq $0x10, %rcx
jmp 0xa38d0
addq $0x110, %rdi            # imm = 0x110
movq %rdi, %rcx
movq (%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: d_v_ok
static bool d_v_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_v_t flt_func;
                    flt_func = s7_d_v_function(s_func);
                    if (flt_func)
                    {
                        s7_pointer sig;
                        sig = c_function_signature(s_func);
                        if ((is_pair(sig)) &&
                                (is_symbol(cadr(sig))) &&
                                (is_symbol(cadr(car_x))))           /* look for (oscil g) */
                        {
                            s7_pointer slot;
                            slot = opt_types_match(sc, cadr(sig), cadr(car_x));
                            if (slot)
                            {
                                opc->v[1].p = slot;
                                opc->v[5].obj = (void *)c_object_value(slot_value(slot));
                                opc->v[3].d_v_f = flt_func;
                                opc->v[0].fd = opt_d_v;
                                return(oo_set_type_1(opc, 6, 1 + (5 << 4), OO_V));
                            }}}
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x4740d
testq %rax, %rax
je 0xa3f83
movq %rax, %r14
movq 0x8(%r13), %rax
movq 0x38(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa3f83
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpb $0xa, (%rsi)
jne 0xa3f83
movq 0x10(%r12), %rax
movq 0x8(%rax), %rdx
cmpb $0xa, (%rdx)
jne 0xa3f83
movq %r15, %rdi
callq 0xc2a5c
testq %rax, %rax
je 0xa3f83
movq %rax, 0x8(%rbx)
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rbx)
movq %r14, 0x18(%rbx)
leaq 0x3143(%rip), %rax      # 0xa70aa
movq %rax, (%rbx)
movabsq $0x100000006, %rax      # imm = 0x100000006
movq %rax, 0x60(%rbx)
movl $0x3, 0x70(%rbx)
movb $0x1, %al
jmp 0xa3f85
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: d_p_ok
static bool d_p_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_p_t dpf;
                    int32_t start;
                    start = sc->pc;
                    dpf = s7_d_p_function(s_func);
                    if (dpf)
                    {
                        opc->v[3].d_p_f = dpf;
                        if (is_symbol(cadr(car_x)))
                        {
                            s7_pointer slot;
                            slot = opt_simple_symbol(sc, cadr(car_x));
                            if (slot)
                            {
                                opc->v[1].p = slot;
                                opc->v[0].fd = opt_d_p_s;
                                return(oo_set_type_1(opc, 4, 1, OO_P));
                            }
                            return(return_false(sc, car_x, __func__, __LINE__));
                        }
                        if (cell_optimize(sc, cdr(car_x)))
                        {
                            opc->v[0].fd = opt_d_p_f;
                            return(oo_set_type_0(opc, 4));
                        }
                        pc_fallback(sc, start);
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2258(%rdi), %ebp
movq %rdx, %rdi
callq 0x4774d
testq %rax, %rax
je 0xa4027
movq %rax, 0x18(%rbx)
movq 0x10(%r15), %rsi
movq 0x8(%rsi), %rax
cmpb $0xa, (%rax)
jne 0xa3ffe
movq %r14, %rdi
movq %rax, %rsi
callq 0xac2d6
movq %rax, %rcx
testq %rax, %rax
setne %al
je 0xa4029
movq %rcx, 0x8(%rbx)
leaq 0x1f088(%rip), %rax     # 0xc306c
movq %rax, (%rbx)
movabsq $0x100000004, %rax      # imm = 0x100000004
movq %rax, 0x60(%rbx)
movl $0x0, 0x70(%rbx)
jmp 0xa401c
movq %r14, %rdi
callq 0xa8bbb
testb %al, %al
je 0xa4020
leaq 0x1f069(%rip), %rax     # 0xc307a
movq %rax, (%rbx)
movq $0x4, 0x60(%rbx)
movb $0x1, %al
jmp 0xa4029
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: d_ip_ok
static bool d_ip_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_ip_t pfunc;
                    pfunc = s7_d_ip_function(s_func);
                    if ((pfunc) &&
                            (is_symbol(caddr(car_x))))
                    {
                        s7_pointer p;
                        p = opt_integer_symbol(sc, cadr(car_x));
                        if (p)
                        {
                            opc->v[3].d_ip_f = pfunc;
                            opc->v[1].p = p;
                            opc->v[2].p = symbol_to_slot(sc, caddr(car_x));
                            if (is_slot(opc->v[2].p))
                            {
                                /* (with-sound (:reverb jc-reverb) (fm-violin 0 .1 440 .4 :reverb-amount .5)) */
                                opc->v[0].fd = opt_d_ip_ss;
                                return(oo_set_type_2(opc, 4, 1, 2, OO_I, OO_P));
                            }}}
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4767d
testq %rax, %rax
je 0xa4eef
movq %rax, %r12
movq 0x10(%r15), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rcx
cmpb $0xa, (%rcx)
jne 0xa4eef
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xa639f
testq %rax, %rax
je 0xa4eef
movq %r12, 0x18(%rbx)
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%r14), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rax), %rsi
movl $0x18, %ecx
cmpq %rsi, %rdi
je 0xa4ebe
jle 0xa4e82
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rsi
jl 0xa4e75
cmpq %rsi, %rdi
je 0xa4ebe
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xa4ebe
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
sete %r8b
je 0xa4eaa
cmpq %rax, 0x8(%rsi)
je 0xa4ead
movq 0x18(%rsi), %rsi
jmp 0xa4e95
movq %rdi, %rsi
testb %r8b, %r8b
je 0xa4ec2
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rsi, %rdi
je 0xa4e91
movq (%rax,%rcx), %rsi
movq %rsi, 0x10(%rbx)
cmpb $0x20, (%rsi)
jne 0xa4eef
leaq 0x1f642(%rip), %rax     # 0xc4514
movq %rax, (%rbx)
movabsq $0x200000004, %rax      # imm = 0x200000004
movq %rax, 0x60(%rbx)
movq $0x1, 0x70(%rbx)
movb $0x1, %al
jmp 0xa4ef1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: d_vdd_ok
static bool d_vdd_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_vdd_t flt;
                    flt = s7_d_vdd_function(s_func);
                    if (flt)
                    {
                        s7_pointer sig;
                        opc->v[4].d_vdd_f = flt;
                        sig = c_function_signature(s_func);
                        if (is_pair(sig))
                        {
                            s7_pointer slot;
                            slot = opt_types_match(sc, cadr(sig), cadr(car_x));
                            if (slot)
                            {
                                int32_t start;
                                start = sc->pc;
                                if ((float_optimize(sc, cddr(car_x))) &&
                                        (float_optimize(sc, cdddr(car_x))))
                                {
                                    opc->v[1].p = slot;
                                    opc->v[5].obj = (void *)c_object_value(slot_value(slot));
                                    opc->v[0].fd = opt_d_vdd_ff;
                                    return(oo_set_type_1(opc, 6, 1 + (5 << 4), OO_V));
                                }
                                pc_fallback(sc, start);
                            }}}
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x474dd
testq %rax, %rax
je 0xa58e2
movq %rax, 0x20(%rbx)
movq 0x8(%r12), %rax
movq 0x38(%rax), %rax
cmpb $0x1, (%rax)
jne 0xa58e2
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0xc2a5c
testq %rax, %rax
je 0xa58e2
movq %rax, %r12
movl 0x2258(%r14), %ebp
movq 0x10(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x47b96
testb %al, %al
je 0xa58db
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x47b96
testb %al, %al
je 0xa58db
movq %r12, 0x8(%rbx)
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rbx)
leaq 0x1f042(%rip), %rax     # 0xc4901
movq %rax, (%rbx)
movabsq $0x100000006, %rax      # imm = 0x100000006
movq %rax, 0x60(%rbx)
movl $0x3, 0x70(%rbx)
movb $0x1, %al
jmp 0xa58e4
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: d_dddd_ok
static bool d_dddd_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_dddd_t f;
                    f = s7_d_dddd_function(s_func);
                    if (f)
                    {
                        if ((float_optimize(sc, cdr(car_x))) &&
                                (float_optimize(sc, cddr(car_x))) &&
                                (float_optimize(sc, cdddr(car_x))) &&
                                (float_optimize(sc, cddddr(car_x))))
                        {
                            opc->v[1].d_dddd_f = f;
                            opc->v[0].fd = opt_d_dddd_ffff;
                            return(oo_set_type_0(opc, 2));
                        }
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x47955
testq %rax, %rax
je 0xa5bc3
movq %rax, %r14
movq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x47b96
testb %al, %al
je 0xa5bc3
movq 0x10(%r12), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x47b96
testb %al, %al
je 0xa5bc3
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x47b96
testb %al, %al
je 0xa5bc3
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x47b96
testb %al, %al
je 0xa5bc3
movq %r14, 0x8(%rbx)
leaq 0x1eddc(%rip), %rax     # 0xc4990
movq %rax, (%rbx)
movq $0x2, 0x60(%rbx)
movb $0x1, %al
jmp 0xa5bc5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: d_7piid_ok
static bool d_7piid_ok(s7_scheme *sc, opt_info *opc, s7_pointer s_func, s7_pointer car_x)
                {
                    s7_d_7piid_t f;
                    f = s7_d_7piid_function(s_func);
                    if ((f) &&
                            (is_symbol(cadr(car_x))))
                    {
                        opc->v[4].d_7piid_f = f;
                        if (car(car_x) == sc->float_vector_set_symbol)
                            return(opt_float_vector_set(sc, opc, cadr(car_x), cddr(car_x), cdddr(car_x), cddddr(car_x)));
                    }
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
cmpb $0x30, (%rdx)
jb 0xa5c0c
movq 0x8(%rdx), %rax
movq 0x20(%rax), %rdx
testq %rdx, %rdx
sete %r8b
je 0xa5c07
cmpl $0x7, (%rdx)
je 0xa5bfe
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
sete %r8b
je 0xa5c07
cmpl $0x7, (%rdx)
jne 0xa5bec
movq 0x8(%rdx), %rax
xorl %r8d, %r8d
jmp 0xa5c07
testb %r8b, %r8b
je 0xa5c0e
xorl %eax, %eax
testq %rax, %rax
je 0xa5c31
movq 0x10(%rcx), %rdx
movq 0x8(%rdx), %rdx
cmpb $0xa, (%rdx)
jne 0xa5c31
movq %rax, 0x20(%rsi)
movq 0x8(%rcx), %rax
cmpq 0xef8(%rdi), %rax
je 0xa5c34
xorl %eax, %eax
retq
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %r8
movq 0x10(%r8), %r9
jmp 0xa5f60
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: d_add_any_ok
static bool d_add_any_ok(s7_scheme *sc, opt_info *opc, s7_pointer car_x, int32_t len)
                {
                    s7_pointer head;
                    int32_t start;
                    start = sc->pc;
                    head = car(car_x);
                    if ((head == sc->add_symbol) ||
                            (head == sc->multiply_symbol))
                    {
                        s7_pointer p;
                        int32_t cur_len;
                        for (cur_len = 0, p = cdr(car_x); is_pair(p); p = cdr(p), cur_len++)
                            if (!float_optimize(sc, p))
                                break;
                        if (is_null(p))
                        {
                            /* since 2|3|4-arg case is split out above, can cur_len ever be 2? */
                            opc->v[1].i = cur_len;
                            opc->v[0].fd = (head == sc->add_symbol) ? opt_d_add_any_f : opt_d_multiply_any_f;
                            return(oo_set_type_0(opc, 2));
                        }
                    }
                    else
                    {
                        if (head == sc->subtract_symbol)
                        {
                            s7_pointer p;
                            opc->v[1].i = (len - 1);
                            for (p = cdr(car_x); is_pair(p); p = cdr(p))
                                if (!float_optimize(sc, p))
                                    break;
                            if (is_null(p))
                            {
                                opc->v[0].fd = opt_d_subtract_any_f;
                                return(oo_set_type_0(opc, 2));
                            }
                        }
                    }
                    pc_fallback(sc, start);
                    return(return_false(sc, car_x, __func__, __LINE__));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2258(%rdi), %ebp
movq 0x8(%rdx), %r12
cmpq 0xba8(%rdi), %r12
je 0xa5cbd
cmpq 0x1358(%r14), %r12
je 0xa5cbd
cmpq 0x1588(%r14), %r12
jne 0xa5cf2
decl %ecx
movslq %ecx, %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0xa5ca8
movq %r14, %rdi
movq %r15, %rsi
callq 0x47b96
testb %al, %al
jne 0xa5c8f
cmpq 0x110(%r14), %r15
jne 0xa5cf2
leaq 0x1ee57(%rip), %rax     # 0xc4b0f
movq %rax, (%rbx)
jmp 0xa5d1d
movq 0x10(%r15), %r15
xorl %r13d, %r13d
cmpb $0x1, (%r15)
jne 0xa5ce9
movq %r14, %rdi
movq %r15, %rsi
callq 0x47b96
testb %al, %al
je 0xa5ce6
incl %r13d
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
je 0xa5cca
movl %r13d, %r13d
cmpq 0x110(%r14), %r15
je 0xa5cfd
movl %ebp, 0x2258(%r14)
xorl %eax, %eax
jmp 0xa5d27
movq %r13, 0x8(%rbx)
cmpq 0xba8(%r14), %r12
leaq 0x1ed34(%rip), %rax     # 0xc4a43
leaq 0x1ed8e(%rip), %rcx     # 0xc4aa4
cmoveq %rax, %rcx
movq %rcx, (%rbx)
movq $0x2, 0x60(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_macroexpand
static s7_pointer s7_macroexpand(s7_scheme *sc, s7_pointer mac, s7_pointer args)
                {
                    push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                    sc->code = mac;
                    sc->args = copy_list_with_arglist_error(sc, args);
                    new_frame(sc, closure_let(sc->code), sc->envir);
                    eval(sc, OP_APPLY_LAMBDA);
                    return(sc->value);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x8(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1df, 0x18(%rax)      # imm = 0x1DF
addq $0x20, 0x50(%rdi)
movq %rsi, (%rdi)
movq %rdx, %rsi
callq 0xc4b92
movq %rax, 0x10(%rbx)
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xa5d94
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x20001c, (%rax)       # imm = 0x20001C
movq 0x250(%rbx), %rcx
incq %rcx
movq %rcx, 0x250(%rbx)
movq %rcx, 0x18(%rax)
movq $0x0, 0x8(%rax)
movq (%rbx), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movl $0x311, %esi            # imm = 0x311
movq %rbx, %rdi
callq 0x10b83
movq 0x20(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_real_symbol
static s7_pointer opt_real_symbol(s7_scheme *sc, s7_pointer sym)
                {
                    if (is_symbol(sym))
                    {
                        s7_pointer p;
                        p = symbol_to_slot(sc, sym);
                        if ((is_slot(p)) &&
                                (is_real(slot_value(p))))
                            return(p);
                    }
                    return(NULL);
                }

// Assembly:
cmpb $0xa, (%rsi)
jne 0xa5e79
movq 0x8(%rdi), %rdx
movq 0x18(%rdx), %rdi
movq 0x20(%rsi), %rax
movl $0x18, %ecx
cmpq %rax, %rdi
je 0xa5e5c
jle 0xa5e20
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdi
cmpq %rdi, %rax
jl 0xa5e13
cmpq %rax, %rdi
je 0xa5e5c
movl $0x10, %ecx
cmpb $0x1c, (%rdx)
jne 0xa5e5c
movq 0x8(%rdx), %rax
testq %rax, %rax
sete %r8b
je 0xa5e48
cmpq %rsi, 0x8(%rax)
je 0xa5e4b
movq 0x18(%rax), %rax
jmp 0xa5e33
movq %rdi, %rax
testb %r8b, %r8b
je 0xa5e60
movq 0x10(%rdx), %rdx
cmpb $0x1c, (%rdx)
movq %rax, %rdi
je 0xa5e2f
movq (%rsi,%rcx), %rax
cmpb $0x20, (%rax)
jne 0xa5e79
movq 0x10(%rax), %rcx
movzbl (%rcx), %ecx
leaq 0xacb3d(%rip), %rdx     # 0x1529b0
cmpb $0x0, (%rcx,%rdx)
jne 0xa5e7b
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_D_s
static s7_double opt_D_s(opt_info *o)
                {
                    s7_pointer x;
                    oo_rc(o->sc, o, 2, 1);
                    x = slot_value(o->v[1].p);
                    if (is_t_integer(x)) return((s7_double)(integer(x)));
                    return(s7_number_to_real(o->sc, x));
                }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0xa5e9e
cvtsi2sdq 0x8(%rsi), %xmm0
retq
movq 0x68(%rdi), %rdi
leaq 0x6d098(%rip), %rdx     # 0x112f41
jmp 0xe212
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_set_d_d_fm
static s7_double opt_set_d_d_fm(opt_info *o)
                {
                    opt_info *o1;
                    s7_double x;
                    o1 = o->sc->opts[++o->sc->pc];
                    x = o1->v[0].fd(o1);
                    oo_rc(o->sc, o, 2, 1);
                    real(slot_value(o->v[1].p)) = x;
                    return(x);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movsd %xmm0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_set_d_d_f
static s7_double opt_set_d_d_f(opt_info *o)
                {
                    opt_info *o1;
                    s7_double x;
                    o1 = o->sc->opts[++o->sc->pc];
                    x = o1->v[0].fd(o1);
                    oo_rc(o->sc, o, 2, 1);
                    slot_set_value(o->v[1].p, make_real(o->sc, x));
                    return(x);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movslq 0x2258(%rax), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x2258(%rax)
movq 0x2268(%rax,%rcx,8), %rdi
callq *(%rdi)
movq 0x68(%rbx), %rdi
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0xa5f2c
movsd %xmm0, 0x8(%rsp)
callq 0xb389
movsd 0x8(%rsp), %xmm0
movq 0x68(%rbx), %rax
movq 0x90(%rax), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x90(%rax)
movq -0x8(%rcx), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
addq $0x10, %rsp
popq %rbx
retq