LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: compatible_types
static bool compatible_types(s7_scheme *sc, s7_pointer eq_type, s7_pointer value_type)
                {
                    if (eq_type == sc->T) return(true);
                    if (eq_type == value_type) return(true);

                    if (eq_type == sc->is_number_symbol)              /* only = among built-ins, so otherr cases aren't needed */
                        return((value_type == sc->is_integer_symbol) ||
                                (value_type == sc->is_real_symbol) ||
                                (value_type == sc->is_complex_symbol) ||
                                (value_type == sc->is_rational_symbol));

                    return(false);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x118(%rcx), %rax
jne 0x1cf8dc
movb $0x1, -0x1(%rsp)
jmp 0x1cf979
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jne 0x1cf8f2
movb $0x1, -0x1(%rsp)
jmp 0x1cf979
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x1120(%rcx), %rax
jne 0x1cf974
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rdx
movb $0x1, %al
cmpq 0x10d0(%rdx), %rcx
movb %al, -0x21(%rsp)
je 0x1cf968
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rdx
movb $0x1, %al
cmpq 0x1180(%rdx), %rcx
movb %al, -0x21(%rsp)
je 0x1cf968
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rdx
movb $0x1, %al
cmpq 0x1038(%rdx), %rcx
movb %al, -0x21(%rsp)
je 0x1cf968
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x1178(%rcx), %rax
sete %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1cf979
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: cyclic_sequences
static s7_pointer cyclic_sequences(s7_scheme *sc, s7_pointer obj)
    {
        if (has_structure(obj))
        {
            shared_info *ci;
            if (sc->object_out_locked)
                ci = sc->circle_info;
            else ci = make_shared_info(sc, obj, false); /* false=don't stop at print length (vectors etc) */
            if (ci)
            {
                int32_t i;
                s7_pointer lst;
                sc->w = sc->nil;
                for (i = 0; i < ci->top; i++)
                    sc->w = cons(sc, ci->objs[i], sc->w);
                lst = sc->w;
                sc->w = sc->nil;
                return(lst);
            }
        }
        return(sc->nil);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x524f1(%rip), %rax     # 0x221e90
testb $0x1, (%rax,%rcx)
je 0x1cfb3a
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x15, %eax
jne 0x1cf9cd
movq 0x40(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x1cfb3a
movq 0x48(%rsp), %rax
testb $0x1, 0x24b(%rax)
je 0x1cf9ee
movq 0x48(%rsp), %rax
movq 0x6c0(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x1cfa04
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0xd05f0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x1cfb38
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1cfb03
movq 0x38(%rsp), %rax
movq (%rax), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1cfa8d
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1cfa30
movq 0x48(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x1cfb4b
jmp 0x1cfb3a
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: apply_list_star
static s7_pointer apply_list_star(s7_scheme *sc, s7_pointer d)
                {
                    s7_pointer p;
                    /* we check this ahead of time: if (is_null(cdr(d))) return(car(d)); */
                    p = cons(sc, car(d), cdr(d));
                    sc->w = p;
                    while (is_not_null(cddr(p)))
                    {
                        d = cdr(d);
                        set_cdr(p, cons(sc, car(d), cdr(d)));
                        if (is_not_null(cdr(d)))
                            p = cdr(p);
                    }
                    set_cdr(p, cadr(p));
                    return(sc->w);
                }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x50(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1cfbae
movq 0x50(%rsp), %rdi
callq 0xc670
movq 0x50(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x50(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x1cfd16
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x50(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1cfc8b
movq 0x50(%rsp), %rdi
callq 0xc670
movq 0x50(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x50(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x1cfd11
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x1cfc1e
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq 0x4d8(%rax), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: for_each_arg_is_null
static inline bool for_each_arg_is_null(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer p;
                    bool got_nil = false;
                    for (p = args; is_pair(p); p = cdr(p))
                    {
                        s7_pointer obj;
                        obj = car(p);
                        if (!is_mappable(obj))
                        {
                            if (is_null(obj))
                                got_nil = true;
                            else return(simple_wrong_type_argument_with_type(sc, sc->for_each_symbol, obj, a_sequence_string));
                        }
                    }
                    return(got_nil);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1cfe05
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x551f3(%rip), %rax     # 0x224f80
testb $0x1, (%rax,%rcx)
jne 0x1cfdf0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x1cfdad
movb $0x1, 0x17(%rsp)
jmp 0x1cfdee
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xf18(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x4a966(%rip), %r8      # 0x21a740
callq 0x14a60
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x1cfe0f
jmp 0x1cfdf0
jmp 0x1cfdf2
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x1cfd5d
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_iterators
static s7_pointer make_iterators(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer p;
                    sc->temp3 = args;
                    sc->z = sc->nil;                                    /* don't use sc->args here -- it needs GC protection until we get the iterators */
                    for (p = cdr(args); is_pair(p); p = cdr(p))
                    {
                        s7_pointer iter;
                        iter = car(p);
                        if (!is_iterator(car(p)))
                            iter = s7_make_iterator(sc, iter);
                        sc->z = cons(sc, iter, sc->z);
                    }
                    sc->temp3 = sc->nil;
                    return(safe_reverse_in_place(sc, sc->z));
                }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x508(%rax)
movq 0x40(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x4f0(%rax)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1cff61
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1d, %eax
je 0x1cfea9
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xdb80
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x4f0(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1cfee8
movq 0x40(%rsp), %rdi
callq 0xc670
movq 0x40(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x4f0(%rax)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1cfe65
movq 0x40(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x508(%rax)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x4f0(%rax), %rsi
callq 0xe460
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_dwind_thunk
static bool is_dwind_thunk(s7_scheme *sc, s7_pointer x)
                {
                    switch (type(x))
                    {
                        case T_MACRO: case T_BACRO: case T_CLOSURE: case T_MACRO_STAR: case T_BACRO_STAR:  case T_CLOSURE_STAR:
                            return(is_null(closure_args(x))); /* this is the case that does not match is_aritable -- it could be loosened -- arity=0 below would need fixup */

                        case T_C_RST_ARGS_FUNCTION: case T_C_FUNCTION:
                            return((c_function_required_args(x) <= 0) && (c_function_all_args(x) >= 0));

                        case T_C_OPT_ARGS_FUNCTION: case T_C_ANY_ARGS_FUNCTION: case T_C_FUNCTION_STAR:
                            return(c_function_all_args(x) >= 0);

                        case T_C_MACRO:
                            return((c_macro_required_args(x) <= 0) && (c_macro_all_args(x) >= 0));

                        case T_GOTO: case T_CONTINUATION:
                            return(true);
                    }
                    return(false);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
addl $-0x25, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rsp)
subl $0xe, %eax
ja 0x1d0074
movq -0x20(%rsp), %rax
leaq 0x111e7(%rip), %rcx     # 0x1e11b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1d0079
movq -0x18(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x21(%rsp)
jg 0x1d001d
movq -0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
setge %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1d0079
movq -0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
setge %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1d0079
movq -0x18(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x22(%rsp)
jg 0x1d0061
movq -0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
setge %al
movb %al, -0x22(%rsp)
movb -0x22(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1d0079
movb $0x1, -0x1(%rsp)
jmp 0x1d0079
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: closure_or_f
static s7_pointer closure_or_f(s7_scheme *sc, s7_pointer p)
                {
                    s7_pointer body;
                    if (!is_closure(p)) return(p);
                    body = closure_body(p);
                    if (is_pair(cdr(body))) return(p);
                    if (!is_pair(car(body))) return(sc->F);
                    if (caar(body) == sc->quote_symbol) return(sc->F);
                    return(p);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x28, %eax
je 0x1d00a6
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d012d
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1d00d1
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d012d
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d00f5
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d012d
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0x1d0123
movq -0x10(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d012d
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: make_baffled_closure
static s7_pointer make_baffled_closure(s7_scheme *sc, s7_pointer inp)
                {
                    /* for dynamic-wind to protect initial and final functions from call/cc */
                    s7_pointer nclo, frame;
                    nclo = make_closure(sc, sc->nil, closure_body(inp), type(inp), 0);
                    frame = new_frame_in_env(sc, closure_let(inp)); /* outlet(frame) = closure_let(inp) */
                    make_slot_1(sc, frame, sc->baffle_symbol, make_baffle(sc));
                    closure_set_let(nclo, frame);
                    return(nclo);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x18d250
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xc53b0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x17d8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x198080
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
callq 0xbec0
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: tree_count_at_least
static inline s7_int tree_count_at_least(s7_scheme *sc, s7_pointer x, s7_pointer p, s7_int count, s7_int top)
                {
                    if (p == x) return(count + 1);
                    if (!is_pair(p)) return(count);
                    if (car(p) == sc->quote_symbol) return(count);
                    do
                    {
                        count = tree_count_at_least(sc, x, car(p), count, top);
                        if (count >= top) return(count);
                        p = cdr(p);
                        if (p == x) return(count + 1);
                    } while (is_pair(p));
                    return(count);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x1d023c
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1d0302
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d0258
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d0302
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0x1d027e
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d0302
jmp 0x1d0280
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x1d0200
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jl 0x1d02bf
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d0302
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x1d02e9
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1d0302
jmp 0x1d02eb
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1d0280
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_function_with_class
static s7_pointer make_function_with_class(s7_scheme *sc, s7_pointer cls, const char *name, s7_function f,
                        int32_t required_args, int32_t optional_args, bool rest_arg)
                {
                    s7_pointer uf;
                    /* the "safe_function" business here doesn't matter -- this is after the optimizer decides what is safe */
                    uf = s7_make_safe_function(sc, name, f, required_args, optional_args, rest_arg, NULL);
                    s7_function_set_class(uf, cls);
                    c_function_signature(uf) = c_function_signature(cls);
                    return(uf);
                }

// Assembly:
subq $0x48, %rsp
movb 0x50(%rsp), %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movl %r9d, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movslq 0x24(%rsp), %rcx
movslq 0x20(%rsp), %r8
movb 0x1f(%rsp), %al
xorl %r9d, %r9d
andb $0x1, %al
movzbl %al, %r9d
movq $0x0, (%rsp)
callq 0x396a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1d4180
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_add_i_random
static s7_pointer g_add_i_random(s7_scheme *sc, s7_pointer args)
    {
        s7_int x, y;
        x = integer(car(args));
        y = integer(opt3_any(args)); /* cadadr */
        return(make_integer(sc, x + (s7_int)(y * next_random(sc->default_rng)))); /* (+ -1 (random 1)) -- placement of the (s7_int) cast matters! */
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cvtsi2sdq 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq 0xaa0(%rax), %rdi
callq 0x143a0
movq 0x8(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1d0ab0
movq 0x30(%rsp), %rcx
leaq 0x459da(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x1d0b26
jmp 0x1d0ab2
movq 0x50(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x50(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1d0ad6
movq 0x50(%rsp), %rdi
callq 0xc670
movq 0x50(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0xb, (%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_add_2_ii
static s7_pointer g_add_2_ii(s7_scheme *sc, s7_pointer args)
    {
#if HAVE_OVERFLOW_CHECKS
        s7_int val, x, y;
        x = integer(car(args));
        y = integer(cadr(args));
        if (add_overflow(x, y, &val))
            return(make_real(sc, (double)x + (double)y));
        return(make_integer(sc, val));
#else
        return(make_integer(sc, integer(car(args)) + integer(cadr(args))));
#endif
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rcx
addq 0x48(%rsp), %rcx
seto %al
movq %rcx, 0x58(%rsp)
testb $0x1, %al
jne 0x1d0c41
jmp 0x1d0cd5
cvtsi2sdq 0x50(%rsp), %xmm0
cvtsi2sdq 0x48(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1d0c7d
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq $0xd, (%rax)
movsd 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x1d0d92
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1d0d07
movq 0x28(%rsp), %rcx
leaq 0x45784(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x1d0d7e
jmp 0x1d0d09
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1d0d2d
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0xb, (%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: subtract_chooser
static s7_pointer subtract_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
#if (!WITH_GMP)
                    if (args == 1)
                        return(sc->subtract_1);

                    if (args == 2)
                    {
                        if (ops)
                        {
                            s7_pointer arg1, arg2;
                            arg1 = cadr(expr);
                            arg2 = caddr(expr);
                            if (arg2 == small_int(1)) return(sc->subtract_s1);
                            if (is_t_real(arg1)) return(sc->subtract_f2);
                            if (is_t_real(arg2)) return(sc->subtract_2f);
                        }
                        return(sc->subtract_2);
                    }
                    if (args == 3)
                        return(sc->subtract_3);
#endif
                    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)
cmpl $0x1, -0x1c(%rsp)
jne 0x1d0ff9
movq -0x10(%rsp), %rax
movq 0x1a68(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d10d1
cmpl $0x2, -0x1c(%rsp)
jne 0x1d10ad
testb $0x1, -0x29(%rsp)
je 0x1d109a
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 -0x40(%rsp), %rax
cmpq 0x45445(%rip), %rax     # 0x216488
jne 0x1d1058
movq -0x10(%rsp), %rax
movq 0x1a80(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d10d1
movq -0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x1d1078
movq -0x10(%rsp), %rax
movq 0x1a90(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d10d1
movq -0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x1d1098
movq -0x10(%rsp), %rax
movq 0x1a88(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d10d1
jmp 0x1d109a
movq -0x10(%rsp), %rax
movq 0x1a70(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d10d1
cmpl $0x3, -0x1c(%rsp)
jne 0x1d10c7
movq -0x10(%rsp), %rax
movq 0x1a78(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d10d1
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: multiply_chooser
static s7_pointer multiply_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
#if (!WITH_GMP)
                    if (args == 2)
                    {
                        if (ops)
                            return(chooser_check_arg_types(sc, cadr(expr), caddr(expr), sc->multiply_2,
                                        sc->mul_2_ff, sc->mul_2_ii, sc->mul_2_if, sc->mul_2_fi,
                                        sc->mul_2_xi, sc->mul_2_ix, sc->mul_2_fx, sc->mul_2_xf));
                        return(sc->multiply_2);
                    }
#endif
                    return(f);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
cmpl $0x2, 0x44(%rsp)
jne 0x1d1956
testb $0x1, 0x37(%rsp)
je 0x1d1943
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq 0x50(%rsp), %rax
movq 0x1c30(%rax), %rcx
movq 0x50(%rsp), %rax
movq 0x1ce0(%rax), %r8
movq 0x50(%rsp), %rax
movq 0x1ce8(%rax), %r9
movq 0x50(%rsp), %rax
movq 0x1cf0(%rax), %r15
movq 0x50(%rsp), %rax
movq 0x1cf8(%rax), %r14
movq 0x50(%rsp), %rax
movq 0x1d00(%rax), %rbx
movq 0x50(%rsp), %rax
movq 0x1d08(%rax), %r11
movq 0x50(%rsp), %rax
movq 0x1d10(%rax), %r10
movq 0x50(%rsp), %rax
movq 0x1d18(%rax), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x1d8d60
movq %rax, 0x58(%rsp)
jmp 0x1d1960
movq 0x50(%rsp), %rax
movq 0x1c30(%rax), %rax
movq %rax, 0x58(%rsp)
jmp 0x1d1960
movq 0x48(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_mul_2_ii
static s7_pointer g_mul_2_ii(s7_scheme *sc, s7_pointer args)
    {
#if HAVE_OVERFLOW_CHECKS
        s7_int val, x, y;
        x = integer(car(args));
        y = integer(cadr(args));
        if (multiply_overflow(x, y, &val))
            return(make_real(sc, (double)x * (double)y));
        return(make_integer(sc, val));
#else
        return(make_integer(sc, integer(car(args)) * integer(cadr(args))));
#endif
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rcx
imulq 0x48(%rsp), %rcx
seto %al
movq %rcx, 0x58(%rsp)
testb $0x1, %al
jne 0x1d1a72
jmp 0x1d1b06
cvtsi2sdq 0x50(%rsp), %xmm0
cvtsi2sdq 0x48(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1d1aae
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq $0xd, (%rax)
movsd 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x1d1bc3
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1d1b38
movq 0x28(%rsp), %rcx
leaq 0x44953(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x1d1baf
jmp 0x1d1b3a
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1d1b5e
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0xb, (%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: divide_chooser
static s7_pointer divide_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
#if (!WITH_GMP)
                    if (args == 1)
                        return(sc->invert_1);
                    if (ops)
                    {
                        if (args == 2)
                        {
                            s7_pointer arg1;
                            arg1 = cadr(expr);
                            if ((is_t_real(arg1)) && (real(arg1) == 1.0))
                                return(sc->divide_1r);
                            if ((is_t_integer(caddr(expr))) && (integer(caddr(expr)) == 2))
                                return(sc->divide_by_2);
                            return(sc->divide_2);
                        }
                    }
#endif
                    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)
cmpl $0x1, -0x1c(%rsp)
jne 0x1d1e69
movq -0x10(%rsp), %rax
movq 0x1c38(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d1f2e
testb $0x1, -0x29(%rsp)
je 0x1d1f24
cmpl $0x2, -0x1c(%rsp)
jne 0x1d1f22
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x1d1ecb
movq -0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0xfab8(%rip), %xmm1     # 0x1e1968
ucomisd %xmm1, %xmm0
jne 0x1d1ecb
jp 0x1d1ecb
movq -0x10(%rsp), %rax
movq 0x1c40(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d1f2e
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1d1f0f
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpq $0x2, 0x8(%rax)
jne 0x1d1f0f
movq -0x10(%rsp), %rax
movq 0x1c50(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d1f2e
movq -0x10(%rsp), %rax
movq 0x1c48(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d1f2e
jmp 0x1d1f24
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: g_invert_1
static s7_pointer g_invert_1(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer p;
        p = car(args);
        switch (type(p))
        {
            case T_INTEGER:
                if (integer(p) != 0)
                    return(s7_make_ratio(sc, 1, integer(p)));      /* a already checked, not 0 */
                return(division_by_zero_error(sc, sc->divide_symbol, args));

            case T_RATIO:
                return(make_simple_ratio(sc, denominator(p), numerator(p)));

            case T_REAL:
                if (real(p) != 0.0)
                    return(make_real(sc, 1.0 / real(p)));
                return(division_by_zero_error(sc, sc->divide_symbol, args));

            case T_COMPLEX:
                return(complex_invert(sc, p));

            default:
                return(method_or_bust_with_type(sc, p, sc->divide_symbol, args, a_number_string, 1));
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
addl $-0xb, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x3, %eax
ja 0x1d20e8
movq 0x8(%rsp), %rax
leaq 0xf2a1(%rip), %rcx      # 0x1e1224
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1d1fba
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdx
movl $0x1, %esi
callq 0x11a80
movq %rax, 0x40(%rsp)
jmp 0x1d211a
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0xe88(%rax), %rsi
movq 0x30(%rsp), %rdx
callq 0x123b0
movq %rax, 0x40(%rsp)
jmp 0x1d211a
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x1bb0a0
movq %rax, 0x40(%rsp)
jmp 0x1d211a
movq 0x28(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1d201f
jp 0x1d201f
jmp 0x1d20b0
movq 0x28(%rsp), %rax
movsd 0xf93c(%rip), %xmm0     # 0x1e1968
divsd 0x8(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x38(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1d205b
movq 0x38(%rsp), %rdi
callq 0xc670
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0xd, (%rax)
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1d211a
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0xe88(%rax), %rsi
movq 0x30(%rsp), %rdx
callq 0x123b0
movq %rax, 0x40(%rsp)
jmp 0x1d211a
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1c0e40
movq %rax, 0x40(%rsp)
jmp 0x1d211a
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0xe88(%rax), %rdx
movq 0x30(%rsp), %rcx
movq 0x52de6(%rip), %r8      # 0x224ef0
movl $0x1, %r9d
callq 0x14130
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_divide_1r
static s7_pointer g_divide_1r(s7_scheme *sc, s7_pointer args)
    {
        if (s7_is_real(cadr(args)))
        {
            s7_double rl;
            rl = s7_real(cadr(args));
            if (rl == 0.0)
                return(division_by_zero_error(sc, sc->divide_symbol, args));
            return(make_real(sc, 1.0 / rl));
        }
        return(g_divide(sc, args));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x11360
testb $0x1, %al
jne 0x1d2159
jmp 0x1d2232
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x128d0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1d21a7
jp 0x1d21a7
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xe88(%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0x123b0
movq %rax, 0x30(%rsp)
jmp 0x1d2246
movsd 0xf7b9(%rip), %xmm0     # 0x1e1968
divsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1d21df
movq 0x28(%rsp), %rdi
callq 0xc670
movq 0x28(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0xd, (%rax)
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d2246
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7de10
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: num_eq_chooser
static s7_pointer num_eq_chooser(s7_scheme *sc, s7_pointer ur_f, int32_t args, s7_pointer expr, bool ops)
                {
                    if (args == 2)
                    {
                        if ((ops) && (s7_is_integer(caddr(expr))))
                            return(sc->num_eq_xi);
                        if ((ops) && (s7_is_integer(cadr(expr))))
                            return(sc->num_eq_ix);
                        return(sc->num_eq_2);
                    }
                    return(ur_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)
cmpl $0x2, 0x1c(%rsp)
jne 0x1d2962
testb $0x1, 0xf(%rsp)
je 0x1d291d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x11340
testb $0x1, %al
jne 0x1d290a
jmp 0x1d291d
movq 0x28(%rsp), %rax
movq 0x1c60(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d296c
testb $0x1, 0xf(%rsp)
je 0x1d294f
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x11340
testb $0x1, %al
jne 0x1d293c
jmp 0x1d294f
movq 0x28(%rsp), %rax
movq 0x1c68(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d296c
movq 0x28(%rsp), %rax
movq 0x1c58(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d296c
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_num_eq_ix
static s7_pointer g_num_eq_ix(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer x, y;
        x = car(args);
        y = cadr(args);
        if (is_t_integer(y))
            return(make_boolean(sc, integer(x) == integer(y)));
        if (is_t_real(y))
            return(make_boolean(sc, integer(x) == real(y)));
        if (!is_number(y))
            return(eq_out_x(sc, y, x));
        return(sc->F);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1d2a02
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d29e2
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1d29f3
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d2a98
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x1d2a55
movq 0x18(%rsp), %rax
cvtsi2sdq 0x8(%rax), %xmm0
movq 0x10(%rsp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x1d2a3a
jp 0x1d2a3a
movq 0x28(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, (%rsp)
jmp 0x1d2a4a
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1d2a98
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x47a3a(%rip), %rax     # 0x21a4a0
testb $0x1, (%rax,%rcx)
jne 0x1d2a87
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x173860
movq %rax, 0x30(%rsp)
jmp 0x1d2a98
movq 0x28(%rsp), %rax
movq 0x120(%rax), %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: less_chooser
static s7_pointer less_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if (args == 2)
                    {
                        if (ops)
                        {
                            s7_pointer arg2;
                            arg2 = caddr(expr);
                            if (is_t_integer(arg2))
                            {
                                if (integer(arg2) == 0)
                                    return(sc->less_x0);

                                if ((integer(arg2) < s7_int32_max) &&
                                        (integer(arg2) > s7_int32_min))
                                    return(sc->less_xi);
                            }
                            if (is_float(arg2))
                                return(sc->less_xf);
                        }
                        return(sc->less_2);
                    }
                    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)
cmpl $0x2, -0x1c(%rsp)
jne 0x1d2b98
testb $0x1, -0x29(%rsp)
je 0x1d2b85
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1d2b63
movq -0x38(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1d2b24
movq -0x10(%rsp), %rax
movq 0x1c80(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2ba2
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x52400(%rip), %rcx     # 0x224f34
cmpq %rcx, %rax
jge 0x1d2b61
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x524bf(%rip), %rcx     # 0x225008
cmpq %rcx, %rax
jle 0x1d2b61
movq -0x10(%rsp), %rax
movq 0x1c70(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2ba2
jmp 0x1d2b63
movq -0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x1d2b83
movq -0x10(%rsp), %rax
movq 0x1c78(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2ba2
jmp 0x1d2b85
movq -0x10(%rsp), %rax
movq 0x1c88(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2ba2
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: greater_chooser
static s7_pointer greater_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if (args == 2)
                    {
                        if (ops)
                        {
                            s7_pointer arg2;
                            arg2 = caddr(expr);

                            if ((is_t_integer(arg2)) &&
                                    (integer(arg2) < s7_int32_max) &&
                                    (integer(arg2) > s7_int32_min))
                                return(sc->greater_xi);

                            if ((is_t_real(arg2)) &&
                                    (real(arg2) < s7_int32_max) &&
                                    (real(arg2) > s7_int32_min))
                                return(sc->greater_xf);
                        }
                        return(sc->greater_2);
                    }
                    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)
cmpl $0x2, -0x1c(%rsp)
jne 0x1d2ca7
testb $0x1, -0x29(%rsp)
je 0x1d2c94
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1d2c42
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x5231f(%rip), %rcx     # 0x224f34
cmpq %rcx, %rax
jge 0x1d2c42
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x523de(%rip), %rcx     # 0x225008
cmpq %rcx, %rax
jle 0x1d2c42
movq -0x10(%rsp), %rax
movq 0x1c90(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2cb1
movq -0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x1d2c92
movq -0x38(%rsp), %rax
movsd 0x8(%rax), %xmm1
cvtsi2sdl 0x522d3(%rip), %xmm0 # 0x224f34
ucomisd %xmm1, %xmm0
jbe 0x1d2c92
movq -0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
cvtsi2sdl 0x5238f(%rip), %xmm1 # 0x225008
ucomisd %xmm1, %xmm0
jbe 0x1d2c92
movq -0x10(%rsp), %rax
movq 0x1c98(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2cb1
jmp 0x1d2c94
movq -0x10(%rsp), %rax
movq 0x1ca0(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2cb1
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: leq_chooser
static s7_pointer leq_chooser(s7_scheme *sc, s7_pointer f, int32_t args, s7_pointer expr, bool ops)
                {
                    if (args == 2)
                    {
                        if (ops)
                        {
                            s7_pointer arg2;
                            arg2 = caddr(expr);
                            if ((is_t_integer(arg2)) &&
                                    (integer(arg2) < s7_int32_max) &&
                                    (integer(arg2) > s7_int32_min))
                                return(sc->leq_xi);
                        }
                        return(sc->leq_2);
                    }
                    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)
cmpl $0x2, -0x1c(%rsp)
jne 0x1d2faf
testb $0x1, -0x29(%rsp)
je 0x1d2f9c
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1d2f9a
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x51fc7(%rip), %rcx     # 0x224f34
cmpq %rcx, %rax
jge 0x1d2f9a
movq -0x38(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x52086(%rip), %rcx     # 0x225008
cmpq %rcx, %rax
jle 0x1d2f9a
movq -0x10(%rsp), %rax
movq 0x1ca8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2fb9
jmp 0x1d2f9c
movq -0x10(%rsp), %rax
movq 0x1cb0(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1d2fb9
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop