LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: symbol_to_string_uncopied_p
static s7_pointer symbol_to_string_uncopied_p(s7_scheme *sc, s7_pointer sym)
    {
        if (!is_symbol(sym))
            simple_wrong_type_argument(sc, sc->symbol_to_string_symbol, sym, T_SYMBOL);
        if (is_gensym(sym))
            return(make_string_with_length(sc, symbol_name(sym), symbol_name_length(sym)));
        return(symbol_name_cell(sym));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0xa, (%rsi)
je 0xb5d58
movq 0x15c0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0x9cd63(%rip), %r8      # 0x152ab0
movq %rbx, %rdi
movq %r14, %rdx
callq 0xfac8
testb $0x20, 0x3(%r14)
movq 0x8(%r14), %r14
je 0xb5e1b
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb5d87
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200013, (%r14)       # imm = 0x200013
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0xa305
movq %rax, 0x20(%r14)
movq (%rax), %rdi
movq %rdi, 0x10(%r14)
testq %r15, %r15
jle 0xb5dcb
movq %r12, %rsi
movq %r15, %rdx
callq 0x93e0
movq 0x10(%r14), %rax
movb $0x0, (%rax,%r15)
movq %r15, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq 0x738(%rbx), %rbx
movq 0x8(%rbx), %rsi
cmpq %rsi, 0x10(%rbx)
jne 0xb5e08
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movq %r14, (%rax,%rcx,8)
movq %r14, %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: opt_p_call_f
static s7_pointer opt_p_call_f(opt_info *o)
                {
                    opt_info *o1;
                    oo_rc(o->sc, o, 3, 0);
                    o1 = o->sc->opts[++o->sc->pc];
                    return(o->v[2].call(o->sc, set_plist_1(o->sc, o1->v[0].fp(o1))));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rbx
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rax
movq 0x10(%rdi), %r14
movq %rax, %rdi
callq *(%rax)
movq 0x700(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x700(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: p_pi_fc_combinable
static bool p_pi_fc_combinable(s7_scheme *sc, opt_info *opc)
                {
                    if ((sc->pc > 1) &&
                            (opc == sc->opts[sc->pc - 2]))
                    {
                        opt_info *o1;
                        o1 = sc->opts[sc->pc - 1];
                        if (o1->v[0].fp == opt_p_p_s)
                        {
                            opc->v[4].p_p_f = o1->v[2].p_p_f;
                            opc->v[1].p = o1->v[1].p;
                            opc->v[0].fp = opt_p_pi_fco;
                            backup_pc(sc);
                            return(oo_set_type_1(opc, 5, 1, OO_P));
                        }
                    }
                    return(return_false(sc, NULL, __func__, __LINE__));
                }

// Assembly:
movl 0x2258(%rdi), %eax
cmpl $0x2, %eax
jl 0xb61bb
leal -0x2(%rax), %ecx
cmpq %rsi, 0x2260(%rdi,%rcx,8)
jne 0xb61bb
decl %eax
movq 0x2260(%rdi,%rax,8), %rax
leaq -0x35ba(%rip), %rcx     # 0xb2bfc
cmpq %rcx, (%rax)
je 0xb61be
xorl %eax, %eax
retq
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsi)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsi)
leaq 0xff(%rip), %rax        # 0xb62d4
movq %rax, (%rsi)
decl 0x2258(%rdi)
movabsq $0x100000005, %rax      # imm = 0x100000005
movq %rax, 0x60(%rsi)
movl $0x0, 0x70(%rsi)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_p_call_sf
static s7_pointer opt_p_call_sf(opt_info *o)
                {
                    opt_info *o1;
                    s7_pointer po1;
                    s7_scheme *sc;
                    sc = o->sc;
                    o1 = sc->opts[++sc->pc];
                    po1 = o1->v[0].fp(o1);
                    oo_rc(sc, o, 4, 1);
                    return(o->v[3].call(sc, set_plist_2(sc, slot_value(o->v[1].p), po1)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r14
movslq 0x2258(%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%r14)
movq 0x2268(%r14,%rax,8), %rdi
callq *(%rdi)
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rdx
movq 0x10(%rcx), %rcx
movq 0x708(%r14), %rsi
movq %rcx, 0x8(%rsi)
movq 0x710(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x708(%r14), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rdx
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_p_call_fs
static s7_pointer opt_p_call_fs(opt_info *o)
                {
                    opt_info *o1;
                    s7_pointer po1;
                    oo_rc(o->sc, o, 4, 1);
                    o1 = o->sc->opts[++o->sc->pc];
                    po1 = o1->v[0].fp(o1);
                    return(o->v[3].call(o->sc, set_plist_2(o->sc, po1, slot_value(o->v[1].p))));
                }

// 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), %rcx
movq 0x18(%rbx), %rdx
movq 0x68(%rbx), %rdi
movq 0x10(%rcx), %rcx
movq 0x708(%rdi), %rsi
movq %rax, 0x8(%rsi)
movq 0x710(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x708(%rdi), %rsi
popq %rbx
jmpq *%rdx
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_p_call_ff
static s7_pointer opt_p_call_ff(opt_info *o)
                {
                    opt_info *o1;
                    s7_pointer po2;
                    s7_scheme *sc;

                    sc = o->sc;
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    oo_rc(sc, o, 4, 0);
                    o1 = sc->opts[++sc->pc];
                    gc_protect_direct(sc, o1->v[0].fp(o1));
                    o1 = sc->opts[++sc->pc];
                    po2 = o1->v[0].fp(o1);
                    po2 = o->v[3].call(sc, set_plist_2(sc, sc->stack_end[-2], po2));
                    sc->stack_end -= 4;
                    return(po2);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x68(%rdi), %rbx
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq 0x18(%r14), %rcx
movq 0x50(%rbx), %rdx
movq -0x10(%rdx), %rdx
movq 0x708(%rbx), %rsi
movq %rdx, 0x8(%rsi)
movq 0x710(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x708(%rbx), %rsi
movq %rbx, %rdi
callq *%rcx
addq $-0x20, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: int_vector_set_unchecked_p
static s7_pointer int_vector_set_unchecked_p(s7_scheme *sc, s7_pointer v, s7_int i, s7_pointer p)
                {
                    if (!s7_is_integer(p))
                        s7_wrong_type_arg_error(sc, "int-vector-set!", 3, p, "an integer");
                    int_vector(v, i) = s7_integer(p);
                    return(p);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
cmpb $0xb, (%rcx)
je 0xb6546
leaq 0x65343(%rip), %rsi     # 0x11b875
leaq 0x69b29(%rip), %r8      # 0x120062
movl $0x3, %edx
movq %rbx, %rcx
callq 0xe25f
cmpb $0xb, (%rbx)
jne 0xb6551
movq 0x8(%rbx), %rax
jmp 0xb6553
xorl %eax, %eax
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r14,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_p_ppp_fff
static s7_pointer opt_p_ppp_fff(opt_info *o)
                {
                    opt_info *o1;
                    s7_pointer res;
                    s7_scheme *sc;
                    sc = o->sc;
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    oo_rc(sc, o, 4, 0);
                    o1 = sc->opts[++sc->pc];
                    gc_protect_direct(sc, T_Pos(o1->v[0].fp(o1)));
                    o1 = sc->opts[++sc->pc];
                    sc->stack_end[-4] = T_Pos(o1->v[0].fp(o1));
                    o1 = sc->opts[++sc->pc];
                    res = o->v[3].p_ppp_f(sc, sc->stack_end[-2], sc->stack_end[-4], o1->v[0].fp(o1));
                    sc->stack_end -= 4;
                    return(res);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x68(%rdi), %rbx
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq 0x50(%rbx), %rcx
movq %rax, -0x20(%rcx)
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
movq 0x18(%r14), %r12
movq 0x50(%rbx), %rax
movq -0x20(%rax), %r14
movq -0x10(%rax), %r15
callq *(%rdi)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
callq *%r12
addq $-0x20, 0x50(%rbx)
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: fx_hash_increment_1
static inline s7_pointer fx_hash_increment_1(s7_scheme *sc, s7_pointer table, s7_pointer key, s7_pointer arg)
                {
                    hash_entry_t *val;
                    if (!is_hash_table(table))
                        return(((s7_p_ppp_t)opt2_direct(cdr(arg)))(sc, table, key, fx_call(sc, cdddr(arg))));
                    val = (*hash_table_checker(table))(sc, table, key);
                    if (val != sc->unentry)
                    {
                        if (!is_t_integer(hash_entry_value(val)))
                            simple_wrong_type_argument(sc, sc->add_symbol, cadddr(arg), T_INTEGER);

                        hash_entry_set_value(val, make_integer(sc, integer(hash_entry_value(val)) + 1));
                        return(hash_entry_value(val));
                    }
                    s7_hash_table_set(sc, table, key, small_int(1));
                    return(small_int(1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpb $0x1b, (%rsi)
jne 0xb67b7
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0x18(%r12)
cmpq 0x490(%rbx), %rax
je 0xb67eb
movq %rax, %r14
movq 0x20(%rax), %rax
cmpb $0xb, (%rax)
je 0xb6791
movq 0xba8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x10(%r13), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
movq 0x140(%rbx), %rcx
movq 0x9c32f(%rip), %r8      # 0x152ab8
movq %rbx, %rdi
callq 0xfac8
movq 0x20(%r14), %rax
movq 0x8(%rax), %rax
leaq 0x1(%rax), %r15
cmpq $0x7ff, %r15            # imm = 0x7FF
ja 0xb6809
leaq 0x981a3(%rip), %rcx     # 0x14e950
movq 0x8(%rcx,%rax,8), %rax
jmp 0xb6842
movq 0x10(%r13), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rax), %r14
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
movq 0x98166(%rip), %rcx     # 0x14e958
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x38db7
movq 0x98151(%rip), %rax     # 0x14e958
jmp 0xb6846
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xb6821
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x20(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_p_call_ssf
static s7_pointer opt_p_call_ssf(opt_info *o)
                {
                    opt_info *o1;
                    o1 = o->sc->opts[++o->sc->pc];
                    oo_rc(o->sc, o, 5, 2);
                    return(o->v[4].call(o->sc, set_plist_3(o->sc, slot_value(o->v[1].p), slot_value(o->v[2].p), o1->v[0].fp(o1))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rbx
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rax
movq 0x20(%rdi), %r12
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
movq 0x10(%rcx), %r14
movq 0x10(%rdx), %r15
movq %rax, %rdi
callq *(%rax)
movq 0x718(%rbx), %rsi
movq %r14, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %r15, 0x8(%rcx)
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq %rbx, %rdi
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: opt_p_call_ppp
static s7_pointer opt_p_call_ppp(opt_info *o)
                {
                    opt_info *o1;
                    s7_pointer po3;
                    s7_scheme *sc;
                    sc = o->sc;
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    o1 = sc->opts[++sc->pc];
                    oo_rc(sc, o, 3, 0);
                    gc_protect_direct(sc, o1->v[0].fp(o1));
                    o1 = sc->opts[++sc->pc];
                    sc->stack_end[-4] = o1->v[0].fp(o1);
                    o1 = sc->opts[++sc->pc];
                    po3 = o1->v[0].fp(o1);
                    po3 = o->v[2].call(sc, set_plist_3(sc, sc->stack_end[-2], sc->stack_end[-4], po3));
                    sc->stack_end -= 4;
                    return(po3);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x68(%rdi), %rbx
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq 0x50(%rbx), %rcx
movq %rax, -0x20(%rcx)
movslq 0x2258(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x2258(%rbx)
movq 0x2268(%rbx,%rax,8), %rdi
callq *(%rdi)
movq 0x10(%r14), %rcx
movq 0x50(%rbx), %rdx
movq -0x20(%rdx), %rdi
movq -0x10(%rdx), %rdx
movq 0x718(%rbx), %rsi
movq %rdx, 0x8(%rsi)
movq 0x10(%rsi), %rdx
movq %rdi, 0x8(%rdx)
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
callq *%rcx
addq $-0x20, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: let_symbol_is_safe
static bool let_symbol_is_safe(s7_scheme *sc, s7_pointer sym, s7_pointer e)
    {
        if (is_slot(global_slot(sym)))
            return(true);
        if (is_null(e))
            e = sc->rootlet;
        return((!is_with_let_let(e)) &&
                (is_slot(symbol_to_slot(sc, sym))));
    }

// Assembly:
movq 0x10(%rsi), %rcx
movb $0x1, %al
cmpb $0x20, (%rcx)
je 0xb81d8
cmpq %rdx, 0x110(%rdi)
jne 0xb81a3
movq 0x150(%rdi), %rdx
testb $0x4, 0x2(%rdx)
jne 0xb81d9
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsi), %rdx
cmpq %rdx, %rdi
je 0xb81ce
jle 0xb81c9
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
cmpq %rdi, %rdx
jl 0xb81bc
cmpq %rdx, %rdi
jne 0xb81dc
movq 0x18(%rsi), %rcx
cmpb $0x20, (%rcx)
sete %al
retq
xorl %eax, %eax
retq
cmpb $0x1c, (%rax)
jne 0xb81d2
movq 0x8(%rax), %rdx
testq %rdx, %rdx
sete %r8b
je 0xb81fa
cmpq %rsi, 0x8(%rdx)
je 0xb81fd
movq 0x18(%rdx), %rdx
jmp 0xb81e5
movq %rdi, %rdx
testb %r8b, %r8b
je 0xb8210
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
movq %rdx, %rdi
je 0xb81e1
jmp 0xb81d2
movq %rdx, %rcx
jmp 0xb81d2
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_or_and_2
static s7_pointer fx_or_and_2(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p, val;
                    p = cdr(arg);
                    val = fx_call(sc, p);
                    if (val != sc->F) return(val);
                    p = cdadr(p);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    return(fx_call(sc, cdr(p)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r14), %rsi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb8537
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb852f
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_and_3
static s7_pointer fx_and_3(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p, val;
                    p = cdr(arg);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    p = cdr(p);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    return(fx_call(sc, cdr(p)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r14), %rsi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb85bb
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb85bb
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_or_and_3
static s7_pointer fx_or_and_3(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p, val;
                    p = cdr(arg);
                    val = fx_call(sc, p);
                    if (val != sc->F) return(val);
                    p = cdadr(p);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    p = cdr(p);
                    val = fx_call(sc, p);
                    if (val == sc->F) return(val);
                    return(fx_call(sc, cdr(p)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movq 0x8(%r14), %rsi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb85e7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb85df
movq 0x10(%r14), %r14
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
cmpq 0x120(%rbx), %rax
je 0xb85df
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_is_integer_s
static s7_pointer fx_is_integer_s(s7_scheme *sc, s7_pointer arg)
                {
#if WITH_GMP
                    return((s7_is_integer(lookup(sc, cadr(arg)))) ? sc->T : sc->F);
#else
                    return((is_t_integer(lookup(sc, cadr(arg)))) ? sc->T : sc->F);
#endif
                }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb8a17
jle 0xb8a12
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb8a05
cmpq %rdx, %rsi
jne 0xb8a30
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
cmpb $0xb, (%rdx)
setne %al
movq 0x118(%rdi,%rax,8), %rax
retq
cmpb $0x1c, (%rcx)
jne 0xb8a60
movq 0x8(%rcx), %r8
testq %r8, %r8
sete %sil
je 0xb8a52
cmpq %rax, 0x8(%r8)
je 0xb8a4e
movq 0x18(%r8), %r8
jmp 0xb8a39
movq 0x10(%r8), %rdx
testb %sil, %sil
je 0xb8a1f
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xb8a35
movq 0x10(%rax), %rax
jmp 0xb8a1b
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_iterate_p_p
static s7_pointer fx_iterate_p_p(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer iter;
                    iter = lookup(sc, cadr(arg));
                    if (is_iterator(iter))
                        return((iterator_next(iter))(sc, iter));
                    return(method_or_bust_one_arg(sc, iter, sc->iterate_symbol, set_plist_1(sc, iter), T_ITERATOR));
                }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xb8f9b
jle 0xb8f96
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xb8f89
cmpq %rdx, %rsi
jne 0xb8fd2
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
cmpb $0x1d, (%rsi)
jne 0xb8fae
movq 0x28(%rsi), %rax
jmpq *%rax
movq 0x11c8(%rdi), %rdx
movq 0x700(%rdi), %rax
movq %rsi, 0x8(%rax)
movq 0x700(%rdi), %rcx
movl $0x1d, %r8d
jmp 0x9b739
cmpb $0x1c, (%rcx)
jne 0xb9000
movq 0x8(%rcx), %r8
testq %r8, %r8
sete %dl
je 0xb8ff3
cmpq %rax, 0x8(%r8)
je 0xb8fef
movq 0x18(%r8), %r8
jmp 0xb8fdb
movq 0x10(%r8), %rsi
testb %dl, %dl
je 0xb8fa3
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xb8fd7
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xb8f9f
xorl %esi, %esi
jmp 0xb8fa3
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_ss
static s7_pointer fx_num_eq_ss(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    x = lookup(sc, cadr(arg));
                    y = lookup(sc, opt2_sym(cdr(arg)));
                    if ((is_t_integer(x)) && (is_t_integer(y)))
                        return(make_boolean(sc, integer(x) == integer(y)));
                    return(num_eq_p_pp(sc, x, y));
                }

// Assembly:
movq 0x10(%rsi), %rdx
movq 0x8(%rdx), %r8
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rcx
movq 0x20(%r8), %rsi
cmpq %rsi, %rcx
je 0xb9344
movq %rax, %r9
movq %rcx, %r10
jle 0xb933f
movq %rax, %r9
movq 0x10(%r9), %r9
movq 0x18(%r9), %r10
cmpq %r10, %rsi
jl 0xb9332
cmpq %rsi, %r10
jne 0xb939d
movq 0x18(%r8), %rsi
movq 0x10(%rsi), %rsi
movq 0x20(%rdx), %r8
movq 0x20(%r8), %rdx
cmpq %rdx, %rcx
je 0xb936d
jle 0xb9368
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
cmpq %rcx, %rdx
jl 0xb935b
cmpq %rdx, %rcx
jne 0xb93e3
movq 0x18(%r8), %rax
movq 0x10(%rax), %rdx
cmpb $0xb, (%rsi)
jne 0x8fcc9
cmpb $0xb, (%rdx)
jne 0x8fcc9
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%rdx), %rax
setne %cl
movq 0x118(%rdi,%rcx,8), %rax
retq
cmpb $0x1c, (%r9)
jne 0xb93cf
movq 0x8(%r9), %r11
testq %r11, %r11
sete %r10b
je 0xb93c0
cmpq %r8, 0x8(%r11)
je 0xb93bc
movq 0x18(%r11), %r11
jmp 0xb93a7
movq 0x10(%r11), %rsi
testb %r10b, %r10b
je 0xb934c
movq 0x10(%r9), %r9
cmpb $0x1c, (%r9)
je 0xb93a3
movq 0x10(%r8), %rsi
cmpb $0x20, (%rsi)
je 0xb9348
xorl %esi, %esi
jmp 0xb934c
cmpb $0x1c, (%rax)
jne 0xb9415
movq 0x8(%rax), %r9
testq %r9, %r9
sete %cl
je 0xb9404
cmpq %r8, 0x8(%r9)
je 0xb9400
movq 0x18(%r9), %r9
jmp 0xb93ec
movq 0x10(%r9), %rdx
testb %cl, %cl
je 0xb9375
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
je 0xb93e8
movq 0x10(%r8), %rax
cmpb $0x20, (%rax)
je 0xb9371
xorl %edx, %edx
jmp 0xb9375
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_is_eq_ss
static s7_pointer fx_is_eq_ss(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer x, y;
                    x = lookup(sc, cadr(arg));
                    y = lookup(sc, opt2_sym(cdr(arg)));
                    return(make_boolean(sc, (x == y) || ((is_unspecified(x)) && (is_unspecified(y)))));
                }

// Assembly:
movq 0x10(%rsi), %rsi
movq 0x8(%rsi), %r8
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdx
movq 0x20(%r8), %rcx
cmpq %rcx, %rdx
je 0xb9d59
movq %rax, %r9
movq %rdx, %r10
jle 0xb9d54
movq %rax, %r9
movq 0x10(%r9), %r9
movq 0x18(%r9), %r10
cmpq %r10, %rcx
jl 0xb9d47
cmpq %rcx, %r10
jne 0xb9da8
movq 0x18(%r8), %rcx
movq 0x10(%rcx), %rcx
movq 0x20(%rsi), %rsi
movq 0x20(%rsi), %r8
cmpq %r8, %rdx
je 0xb9d82
jle 0xb9d7d
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdx
cmpq %rdx, %r8
jl 0xb9d70
cmpq %r8, %rdx
jne 0xb9dee
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rdx
movl $0x118, %eax            # imm = 0x118
cmpq %rdx, %rcx
je 0xb9da3
cmpb $0x5, (%rcx)
jne 0xb9d9e
cmpb $0x5, (%rdx)
je 0xb9da3
movl $0x120, %eax            # imm = 0x120
movq (%rdi,%rax), %rax
retq
cmpb $0x1c, (%r9)
jne 0xb9dda
movq 0x8(%r9), %r11
testq %r11, %r11
sete %r10b
je 0xb9dcb
cmpq %r8, 0x8(%r11)
je 0xb9dc7
movq 0x18(%r11), %r11
jmp 0xb9db2
movq 0x10(%r11), %rcx
testb %r10b, %r10b
je 0xb9d61
movq 0x10(%r9), %r9
cmpb $0x1c, (%r9)
je 0xb9dae
movq 0x10(%r8), %rcx
cmpb $0x20, (%rcx)
je 0xb9d5d
xorl %ecx, %ecx
jmp 0xb9d61
cmpb $0x1c, (%rax)
jne 0xb9e22
movq 0x8(%rax), %r9
testq %r9, %r9
sete %r8b
je 0xb9e10
cmpq %rsi, 0x8(%r9)
je 0xb9e0c
movq 0x18(%r9), %r9
jmp 0xb9df7
movq 0x10(%r9), %rdx
testb %r8b, %r8b
je 0xb9d8a
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
je 0xb9df3
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xb9d86
xorl %edx, %edx
jmp 0xb9d8a
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table_ref_2
static s7_pointer g_hash_table_ref_2(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer table;
                    table = car(args);
                    if (!is_hash_table(table))
                        return(method_or_bust(sc, table, sc->hash_table_ref_symbol, args, T_HASH_TABLE, 1));
                    return(hash_entry_value((*hash_table_checker(table))(sc, table, cadr(args))));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
cmpb $0x1b, (%rsi)
jne 0xba05e
pushq %rax
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
callq *0x18(%rsi)
movq 0x20(%rax), %rax
popq %rcx
retq
movq 0xf68(%rdi), %rdx
movl $0x1b, %r8d
movl $0x1, %r9d
jmp 0xf1ae
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_sss
static s7_pointer fx_c_sss(s7_scheme *sc, s7_pointer arg)
                {
                    set_car(sc->t3_1, lookup(sc, cadr(arg)));
                    set_car(sc->t3_2, lookup(sc, opt1_sym(cdr(arg)))); /* caddr(arg) */
                    set_car(sc->t3_3, lookup(sc, opt2_sym(cdr(arg)))); /* cadddr(arg) */
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xba527
jle 0xba51e
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xba511
cmpq %rdx, %r8
jne 0xba5cf
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x580(%rdi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rsi), %rax
movq 0x18(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xba56b
jle 0xba562
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xba555
cmpq %rdx, %r8
jne 0xba617
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x588(%rdi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %r8
movq 0x20(%rax), %rdx
cmpq %rdx, %r8
je 0xba5af
jle 0xba5a6
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %r8
cmpq %r8, %rdx
jl 0xba599
cmpq %rdx, %r8
jne 0xba65f
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x590(%rdi), %rax
movq %rdx, 0x8(%rax)
movq 0x20(%rsi), %rax
movq 0x580(%rdi), %rsi
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xba603
movq 0x8(%rcx), %r9
testq %r9, %r9
sete %r8b
je 0xba5f1
cmpq %rax, 0x8(%r9)
je 0xba5ed
movq 0x18(%r9), %r9
jmp 0xba5d8
movq 0x10(%r9), %rdx
testb %r8b, %r8b
je 0xba52f
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xba5d4
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xba52b
xorl %edx, %edx
jmp 0xba52f
cmpb $0x1c, (%rcx)
jne 0xba64b
movq 0x8(%rcx), %r9
testq %r9, %r9
sete %r8b
je 0xba639
cmpq %rax, 0x8(%r9)
je 0xba635
movq 0x18(%r9), %r9
jmp 0xba620
movq 0x10(%r9), %rdx
testb %r8b, %r8b
je 0xba573
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xba61c
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xba56f
xorl %edx, %edx
jmp 0xba573
cmpb $0x1c, (%rcx)
jne 0xba693
movq 0x8(%rcx), %r9
testq %r9, %r9
sete %r8b
je 0xba681
cmpq %rax, 0x8(%r9)
je 0xba67d
movq 0x18(%r9), %r9
jmp 0xba668
movq 0x10(%r9), %rdx
testb %r8b, %r8b
je 0xba5b7
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xba664
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xba5b3
xorl %edx, %edx
jmp 0xba5b7
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_ssa
static s7_pointer fx_c_ssa(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    p = cddr(arg);
                    set_car(sc->t3_3, fx_call(sc, cdr(p)));
                    set_car(sc->t3_1, lookup(sc, cadr(arg)));
                    set_car(sc->t3_2, lookup(sc, car(p)));
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x10(%rax), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xba841
jle 0xba83c
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xba82f
cmpq %rdx, %rsi
jne 0xba8a5
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x580(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x8(%r15), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xba87d
jle 0xba878
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xba86b
cmpq %rdx, %rsi
jne 0xba8ed
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x588(%rbx), %rax
movq %rdx, 0x8(%rax)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xba8d9
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %sil
je 0xba8c7
cmpq %rax, 0x8(%rdi)
je 0xba8c3
movq 0x18(%rdi), %rdi
jmp 0xba8ae
movq 0x10(%rdi), %rdx
testb %sil, %sil
je 0xba849
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xba8aa
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xba845
xorl %edx, %edx
jmp 0xba849
cmpb $0x1c, (%rcx)
jne 0xba921
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %sil
je 0xba90f
cmpq %rax, 0x8(%rdi)
je 0xba90b
movq 0x18(%rdi), %rdi
jmp 0xba8f6
movq 0x10(%rdi), %rdx
testb %sil, %sil
je 0xba885
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xba8f2
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xba881
xorl %edx, %edx
jmp 0xba885
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_gac
static s7_pointer fx_c_gac(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer p;
                    p = cdr(arg);
                    set_car(sc->t3_2, fx_call(sc, cdr(p)));
                    set_car(sc->t3_3, caddr(p));
                    set_car(sc->t3_1, lookup_global(sc, car(p)));
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rsi
testb $0x1, 0x2(%rsi)
jne 0xba9b7
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rdx
movq 0x20(%rsi), %rax
cmpq %rax, %rdx
je 0xba9a0
jle 0xba99b
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdx
cmpq %rdx, %rax
jl 0xba98e
cmpq %rax, %rdx
jne 0xba9df
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xba9bf
movq %rbx, %rdi
callq 0xa2ee9
jmp 0xba9bf
movq 0x10(%rsi), %rax
movq 0x10(%rax), %rax
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xbaa0d
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %dl
je 0xbaa00
cmpq %rsi, 0x8(%rdi)
je 0xba9fc
movq 0x18(%rdi), %rdi
jmp 0xba9e8
movq 0x10(%rdi), %rax
testb %dl, %dl
je 0xba9a8
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xba9e4
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xba9a4
xorl %eax, %eax
jmp 0xba9a8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_aaa
static s7_pointer fx_c_aaa(s7_scheme *sc, s7_pointer arg)
                {
                    check_stack_size(sc);
                    gc_protect_direct(sc, fx_call(sc, cdr(arg)));
                    sc->stack_end[-4] = fx_call(sc, cddr(arg));
                    set_car(sc->t3_3, fx_call(sc, cdddr(arg)));
                    set_car(sc->t3_2, sc->stack_end[-4]);
                    set_car(sc->t3_1, sc->stack_end[-2]);
                    sc->stack_end -= 4;
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpq 0x58(%rdi), %rax
jb 0xbaa36
movq %rbx, %rdi
callq 0xc15d0
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, -0x20(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x20(%rax), %rax
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_3g
static s7_pointer fx_c_3g(s7_scheme *sc, s7_pointer arg)
                {
                    set_car(sc->t3_1, fx_call(sc, cdr(arg)));
                    set_car(sc->t3_2, fx_call(sc, cddr(arg)));
                    set_car(sc->t3_3, fx_call(sc, cdddr(arg)));
                    return(c_call(arg)(sc, sc->t3_1));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
callq *0x20(%rax)
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%r14), %rax
movq 0x580(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_4g
static s7_pointer fx_c_4g(s7_scheme *sc, s7_pointer code) /* all opts in use for code, opt1 free cdr(code), code opt3 is line_number, cdr(code) opt3 is arglen?? */
                {
                    s7_pointer res;
                    res = cdr(code);
                    set_car(sc->t4_1, fx_call(sc, res));
                    set_car(sc->t3_1, fx_call(sc, cdr(res)));
                    set_car(sc->t3_2, fx_call(sc, cddr(res)));
                    set_car(sc->t3_3, fx_call(sc, cdddr(res)));
                    res = c_call(code)(sc, sc->t4_1);
                    set_car(sc->t4_1, sc->F);
                    return(res);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x8(%r15), %rsi
callq *0x20(%r15)
movq 0x5a8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x5a8(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x120(%rbx), %rcx
movq 0x5a8(%rbx), %rdx
movq %rcx, 0x8(%rdx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_4a
static s7_pointer fx_c_4a(s7_scheme *sc, s7_pointer code)
                {
                    s7_pointer res;
#if S7_DEBUGGING
                    if (sc->stack_end >= sc->stack_resize_trigger) fprintf(stderr, "%s[%d]: skipped stack resize\n", __func__, __LINE__);
#endif
                    res = cdr(code);
                    gc_protect_direct(sc, fx_call(sc, res));
                    sc->stack_end[-4] = fx_call(sc, cdr(res));
                    sc->stack_end[-3] = fx_call(sc, cddr(res));
                    set_car(sc->t3_3, fx_call(sc, cdddr(res)));
                    set_car(sc->t3_2, sc->stack_end[-3]);
                    set_car(sc->t3_1, sc->stack_end[-4]);
                    set_car(sc->t4_1, sc->stack_end[-2]);
                    sc->stack_end -= 4;
                    res = c_call(code)(sc, sc->t4_1);
                    set_car(sc->t4_1, sc->F);
                    return(res);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x8(%r15), %rsi
callq *0x20(%r15)
movq 0x50(%rbx), %rcx
movq $0x1, 0x18(%rcx)
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x10(%rcx)
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, -0x20(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x50(%rbx), %rcx
movq %rax, -0x18(%rcx)
movq 0x10(%r15), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x590(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x18(%rax), %rax
movq 0x588(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x20(%rax), %rax
movq 0x580(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq -0x10(%rax), %rax
movq 0x5a8(%rbx), %rcx
movq %rax, 0x8(%rcx)
addq $-0x20, 0x50(%rbx)
movq 0x5a8(%rbx), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x120(%rbx), %rcx
movq 0x5a8(%rbx), %rdx
movq %rcx, 0x8(%rdx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_num_eq_add_ss
static s7_pointer fx_num_eq_add_ss(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs, x, y, z;
                    largs = cdaddr(arg);
                    x = lookup(sc, car(largs));
                    y = lookup(sc, cadr(largs));
                    z = lookup(sc, cadr(arg));
                    if ((is_t_integer(x)) && (is_t_integer(y)) && (is_t_integer(z)))
                        return(make_boolean(sc, (integer(x) + integer(y)) == integer(z)));
                    return(num_eq_p_pp(sc, z, add_p_pp(sc, x, y)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x8(%rdx), %r8
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rcx
movq 0x20(%r8), %rsi
cmpq %rsi, %rcx
je 0xbae69
movq %rax, %r9
movq %rcx, %r10
jle 0xbae60
movq %rax, %r9
movq 0x10(%r9), %r9
movq 0x18(%r9), %r10
cmpq %r10, %rsi
jl 0xbae53
cmpq %rsi, %r10
jne 0xbaf26
movq 0x18(%r8), %rsi
movq 0x10(%rsi), %rsi
movq 0x10(%rdx), %rdx
movq 0x8(%rdx), %r8
movq 0x20(%r8), %rdx
cmpq %rdx, %rcx
je 0xbaea3
movq %rax, %r9
movq %rcx, %r10
jle 0xbae9a
movq %rax, %r9
movq 0x10(%r9), %r9
movq 0x18(%r9), %r10
cmpq %r10, %rdx
jl 0xbae8d
cmpq %rdx, %r10
jne 0xbaf70
movq 0x18(%r8), %rdx
movq 0x10(%rdx), %rdx
movq 0x8(%rdi), %rdi
movq 0x20(%rdi), %r8
cmpq %r8, %rcx
je 0xbaed0
jle 0xbaec7
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
cmpq %rcx, %r8
jl 0xbaeba
cmpq %r8, %rcx
jne 0xbafba
movq 0x18(%rdi), %rax
movq 0x10(%rax), %r14
cmpb $0xb, (%rsi)
jne 0xbaf09
cmpb $0xb, (%rdx)
jne 0xbaf09
cmpb $0xb, (%r14)
jne 0xbaf09
movq 0x8(%rdx), %rax
addq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq 0x8(%r14), %rax
setne %cl
movq 0x118(%rbx,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x8d0a7
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8fcc9
cmpb $0x1c, (%r9)
jne 0xbaf5c
movq 0x8(%r9), %r11
testq %r11, %r11
sete %r10b
je 0xbaf49
cmpq %r8, 0x8(%r11)
je 0xbaf45
movq 0x18(%r11), %r11
jmp 0xbaf30
movq 0x10(%r11), %rsi
testb %r10b, %r10b
je 0xbae71
movq 0x10(%r9), %r9
cmpb $0x1c, (%r9)
je 0xbaf2c
movq 0x10(%r8), %rsi
cmpb $0x20, (%rsi)
je 0xbae6d
xorl %esi, %esi
jmp 0xbae71
cmpb $0x1c, (%r9)
jne 0xbafa6
movq 0x8(%r9), %r11
testq %r11, %r11
sete %r10b
je 0xbaf93
cmpq %r8, 0x8(%r11)
je 0xbaf8f
movq 0x18(%r11), %r11
jmp 0xbaf7a
movq 0x10(%r11), %rdx
testb %r10b, %r10b
je 0xbaeab
movq 0x10(%r9), %r9
cmpb $0x1c, (%r9)
je 0xbaf76
movq 0x10(%r8), %rdx
cmpb $0x20, (%rdx)
je 0xbaea7
xorl %edx, %edx
jmp 0xbaeab
cmpb $0x1c, (%rax)
jne 0xbafec
movq 0x8(%rax), %r8
testq %r8, %r8
sete %cl
je 0xbafdb
cmpq %rdi, 0x8(%r8)
je 0xbafd7
movq 0x18(%r8), %r8
jmp 0xbafc3
movq 0x10(%r8), %r14
testb %cl, %cl
je 0xbaed8
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
je 0xbafbf
movq 0x10(%rdi), %rax
cmpb $0x20, (%rax)
je 0xbaed4
xorl %r14d, %r14d
jmp 0xbaed8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_g_opgsq_direct
static s7_pointer fx_c_g_opgsq_direct(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    arg = cdr(arg);
                    largs = cdadr(arg);
                    return(((s7_p_pp_t)opt2_direct(arg))(sc, lookup_global(sc, car(arg)),
                                ((s7_p_pp_t)opt3_direct(arg))(sc, lookup_global(sc, car(largs)), lookup(sc, opt2_sym(largs)))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r12
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %r15
movq 0x20(%r12), %r13
testb $0x1, 0x2(%rsi)
jne 0xbb415
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rsi), %rcx
cmpq %rcx, %rdx
je 0xbb3fb
jle 0xbb3f2
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdx
cmpq %rdx, %rcx
jl 0xbb3e5
cmpq %rcx, %rdx
jne 0xbb505
movq 0x18(%rsi), %rax
movq 0x10(%rax), %r14
testq %r14, %r14
jne 0xbb41d
movq %rbx, %rdi
callq 0xa2ee9
movq %rax, %r14
jmp 0xbb41d
movq 0x10(%rsi), %rax
movq 0x10(%rax), %r14
movq 0x28(%r12), %r12
movq 0x8(%r15), %rax
testb $0x1, 0x2(%rax)
jne 0xbb472
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rsi
movq 0x20(%rax), %rdx
cmpq %rdx, %rsi
je 0xbb455
jle 0xbb44c
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
jl 0xbb43f
cmpq %rdx, %rsi
jne 0xbb54c
movq 0x18(%rax), %rcx
movq 0x10(%rcx), %rsi
testq %rsi, %rsi
jne 0xbb47a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa2ee9
movq %rax, %rsi
jmp 0xbb47a
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
movq 0x20(%r15), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rdi
movq 0x20(%rax), %rdx
cmpq %rdx, %rdi
je 0xbb4a3
jle 0xbb49e
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rdi
cmpq %rdi, %rdx
jl 0xbb491
cmpq %rdx, %rdi
jne 0xbb4c8
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq *%r12
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%rcx)
jne 0xbb4f8
movq 0x8(%rcx), %r8
testq %r8, %r8
sete %dil
je 0xbb4ea
cmpq %rax, 0x8(%r8)
je 0xbb4e6
movq 0x18(%r8), %r8
jmp 0xbb4d1
movq 0x10(%r8), %rdx
testb %dil, %dil
je 0xbb4ab
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xbb4cd
movq 0x10(%rax), %rax
cmpb $0x20, (%rax)
je 0xbb4a7
xorl %edx, %edx
jmp 0xbb4ab
cmpb $0x1c, (%rax)
jne 0xbb537
movq 0x8(%rax), %rdx
testq %rdx, %rdx
sete %cl
je 0xbb526
cmpq %rsi, 0x8(%rdx)
je 0xbb522
movq 0x18(%rdx), %rdx
jmp 0xbb50e
movq 0x10(%rdx), %r14
testb %cl, %cl
je 0xbb403
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
je 0xbb50a
movq 0x10(%rsi), %rax
cmpb $0x20, (%rax)
je 0xbb3ff
xorl %r14d, %r14d
jmp 0xbb403
cmpb $0x1c, (%rcx)
jne 0xbb57e
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %dl
je 0xbb56d
cmpq %rax, 0x8(%rdi)
je 0xbb569
movq 0x18(%rdi), %rdi
jmp 0xbb555
movq 0x10(%rdi), %rsi
testb %dl, %dl
je 0xbb45d
movq 0x10(%rcx), %rcx
cmpb $0x1c, (%rcx)
je 0xbb551
movq 0x10(%rax), %rcx
cmpb $0x20, (%rcx)
je 0xbb459
xorl %esi, %esi
jmp 0xbb45d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fx_c_s_opssq_direct
static s7_pointer fx_c_s_opssq_direct(s7_scheme *sc, s7_pointer arg)
                {
                    s7_pointer largs;
                    arg = cdr(arg);
                    largs = cdadr(arg);
                    return(((s7_p_pp_t)opt2_direct(arg))(sc, lookup(sc, car(arg)),
                                ((s7_p_pp_t)opt3_direct(arg))(sc, lookup(sc, car(largs)), lookup(sc, opt2_sym(largs)))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rdx
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rsi), %r9
cmpq %r9, %rcx
je 0xbb5e0
movq %rax, %r8
movq %rcx, %r10
jle 0xbb5d7
movq %rax, %r8
movq 0x10(%r8), %r8
movq 0x18(%r8), %r10
cmpq %r10, %r9
jl 0xbb5ca
cmpq %r9, %r10
jne 0xbb66f
movq 0x18(%rsi), %rsi
movq 0x10(%rsi), %r14
movq 0x8(%rdi), %r8
movq 0x20(%r8), %rsi
cmpq %rsi, %rcx
je 0xbb616
movq %rax, %r9
movq %rcx, %r10
jle 0xbb60d
movq %rax, %r9
movq 0x10(%r9), %r9
movq 0x18(%r9), %r10
cmpq %r10, %rsi
jl 0xbb600
cmpq %rsi, %r10
jne 0xbb6ba
movq 0x18(%r8), %rsi
movq 0x10(%rsi), %rsi
movq 0x20(%rdx), %r10
movq 0x28(%rdx), %r8
movq 0x20(%rdi), %rdi
movq 0x20(%rdi), %rdx
cmpq %rdx, %rcx
je 0xbb64b
jle 0xbb642
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
cmpq %rcx, %rdx
jl 0xbb635
cmpq %rdx, %rcx
jne 0xbb704
movq %r10, %r15
movq 0x18(%rdi), %rax
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq *%r8
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
cmpb $0x1c, (%r8)
jne 0xbb6a5
movq 0x8(%r8), %r10
testq %r10, %r10
sete %r9b
je 0xbb692
cmpq %rsi, 0x8(%r10)
je 0xbb68e
movq 0x18(%r10), %r10
jmp 0xbb679
movq 0x10(%r10), %r14
testb %r9b, %r9b
je 0xbb5e8
movq 0x10(%r8), %r8
cmpb $0x1c, (%r8)
je 0xbb675
movq 0x10(%rsi), %rsi
cmpb $0x20, (%rsi)
je 0xbb5e4
xorl %r14d, %r14d
jmp 0xbb5e8
cmpb $0x1c, (%r9)
jne 0xbb6f0
movq 0x8(%r9), %r11
testq %r11, %r11
sete %r10b
je 0xbb6dd
cmpq %r8, 0x8(%r11)
je 0xbb6d9
movq 0x18(%r11), %r11
jmp 0xbb6c4
movq 0x10(%r11), %rsi
testb %r10b, %r10b
je 0xbb61e
movq 0x10(%r9), %r9
cmpb $0x1c, (%r9)
je 0xbb6c0
movq 0x10(%r8), %rsi
cmpb $0x20, (%rsi)
je 0xbb61a
xorl %esi, %esi
jmp 0xbb61e
cmpb $0x1c, (%rax)
jne 0xbb732
movq 0x8(%rax), %r9
testq %r9, %r9
sete %cl
je 0xbb725
cmpq %rdi, 0x8(%r9)
je 0xbb721
movq 0x18(%r9), %r9
jmp 0xbb70d
movq 0x10(%r9), %rdx
testb %cl, %cl
je 0xbb749
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
je 0xbb709
movq %r10, %r15
movq 0x10(%rdi), %rax
cmpb $0x20, (%rax)
je 0xbb652
xorl %edx, %edx
jmp 0xbb656
movq %r10, %r15
jmp 0xbb656