LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: resize_hash_table
static void resize_hash_table(s7_scheme *sc, s7_pointer table)
                {
                    s7_int hash_mask, loc, i, old_size, new_size;
                    hash_entry_t **new_els, **old_els;
                    block_t *np;
                    s7_pointer dproc;
                    s7_int entries;

                    dproc = hash_table_procedures(table); /* new block_t so we need to pass this across */
                    entries = hash_table_entries(table);
                    old_size = hash_table_mask(table) + 1;
                    new_size = old_size * 4;
                    hash_mask = new_size - 1;
                    np = (block_t *)callocate(sc, new_size * sizeof(hash_entry_t *));
                    new_els = (hash_entry_t **)(block_data(np));
                    old_els = hash_table_elements(table);

                    for (i = 0; i < old_size; i++)
                    {
                        hash_entry_t *x, *n;
                        for (x = old_els[i]; x; x = n)
                        {
                            n = hash_entry_next(x);
                            loc = hash_entry_raw_hash(x) & hash_mask;
                            hash_entry_next(x) = new_els[loc];
                            new_els[loc] = x;
                        }
                    }
                    liberate(sc, hash_table_block(table));
                    hash_table_set_block(table, np);
                    hash_table_elements(table) = new_els;
                    hash_table_mask(table) = new_size - 1;
                    hash_table_set_procedures(table, dproc);
                    hash_table_entries(table) = entries;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r13
movq 0x28(%rsi), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x1(%r13), %rsi
leaq 0x3(,%r13,4), %rbp
shlq $0x5, %rsi
callq 0x3f3bd
movq %rax, %r15
movq (%rax), %r12
testq %r13, %r13
js 0x40363
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x40357
movq 0x18(%rdx), %rsi
movq 0x10(%rdx), %rdi
andq %rbp, %rdi
movq (%r12,%rdi,8), %r8
movq %r8, 0x18(%rdx)
movq %rdx, (%r12,%rdi,8)
movq %rsi, %rdx
testq %rsi, %rsi
jne 0x40338
leaq 0x1(%rcx), %rdx
cmpq %r13, %rcx
movq %rdx, %rcx
jne 0x4032f
movq 0x28(%rbx), %r13
movslq 0x8(%r13), %rax
cmpq $0x11, %rax
jne 0x40398
movq (%r13), %rdi
testq %rdi, %rdi
je 0x40387
callq 0x9050
movq $0x0, (%r13)
movl $0x0, 0x8(%r13)
addq $0x838, %r14            # imm = 0x838
jmp 0x403a3
leaq (%r14,%rax,8), %r14
addq $0x838, %r14            # imm = 0x838
movq (%r14), %rax
movq %rax, 0x18(%r13)
movq %r13, (%r14)
movq %r15, 0x28(%rbx)
movq %r12, 0x10(%rbx)
movq %rbp, 0x8(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r15)
movq 0x28(%rbx), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_function
s7_pointer s7_make_function(s7_scheme *sc, const char *name, s7_function f, s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc)
                {
                    s7_pointer x;
                    x = alloc_pointer(sc);
#if S7_DEBUGGING
                    permanent_functions++;
#endif
                    x = make_function(sc, name, f, required_args, optional_args, rest_arg, doc, x, alloc_permanent_function(sc));
                    unheap(sc, x);
                    return(x);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0xfa3b
movq %rax, %rbx
cmpl $0x80, 0x7f4(%r14)
jne 0x40434
movl $0x3400, %edi           # imm = 0x3400
callq 0x9480
movq %rax, 0x808(%r14)
movl $0x0, 0x7f4(%r14)
movl 0x7f4(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x7f4(%r14)
imulq $0x68, %rax, %rax
addq 0x808(%r14), %rax
subq $0x8, %rsp
movzbl %bpl, %r9d
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
pushq %rax
pushq %rbx
pushq 0x58(%rsp)
callq 0x4048e
addq $0x20, %rsp
orb $0x40, 0x7(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_typed_function
s7_pointer s7_make_typed_function(s7_scheme *sc, const char *name, s7_function f,
                        s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc, s7_pointer signature)
                {
                    s7_pointer func;
                    func = s7_make_function(sc, name, f, required_args, optional_args, rest_arg, doc);
                    set_type_bit(func, T_SAFE_PROCEDURE);
                    if (signature) c_function_signature(func) = signature;
                    return(func);
                }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x28(%rsp), %rbx
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
callq 0x403e5
orb $0x20, 0x2(%rax)
testq %rbx, %rbx
je 0x406a5
movq 0x8(%rax), %rcx
movq %rbx, 0x38(%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_define_function
s7_pointer s7_define_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc)
                {
                    s7_pointer func, sym;
                    func = s7_make_function(sc, name, fnc, required_args, optional_args, rest_arg, doc);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x403e5
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa9f
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xce9d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_define_safe_function
s7_pointer s7_define_safe_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc)
                {
                    /* returns (string->symbol name), not the c_proc_t func */
                    s7_pointer func, sym;
                    func = s7_make_safe_function(sc, name, fnc, required_args, optional_args, rest_arg, doc);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x403e5
movq %rax, %r15
orb $0x20, 0x2(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa9f
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xce9d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_define_typed_function
s7_pointer s7_define_typed_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg,
                        const char *doc, s7_pointer signature)
                {
                    /* returns (string->symbol name), not the c_proc_t func */
                    s7_pointer func, sym;
                    func = s7_make_typed_function(sc, name, fnc, required_args, optional_args, rest_arg, doc, signature);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    c_function_set_marker(func, NULL);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x403e5
movq %rax, %r15
orb $0x20, 0x2(%rax)
testq %r12, %r12
je 0x4082b
movq 0x8(%r15), %rax
movq %r12, 0x38(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa9f
movq %rax, %r14
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xce9d
movq 0x8(%r15), %rax
movq $0x0, 0x60(%rax)
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: s7_define_unsafe_typed_function
s7_pointer s7_define_unsafe_typed_function(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg,
                        const char *doc, s7_pointer signature)
                {
                    /* returns (string->symbol name), not the c_proc_t func */
                    s7_pointer func, sym;
                    func = s7_make_function(sc, name, fnc, required_args, optional_args, rest_arg, doc);
                    if (signature) c_function_signature(func) = signature;
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x403e5
movq %rax, %r15
testq %r12, %r12
je 0x4089a
movq 0x8(%r15), %rax
movq %r12, 0x38(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa9f
movq %rax, %r14
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xce9d
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: s7_define_macro
s7_pointer s7_define_macro(s7_scheme *sc, const char *name, s7_function fnc,
                        s7_int required_args, s7_int optional_args, bool rest_arg, const char *doc)
                {
                    s7_pointer func, sym;
                    func = s7_make_function(sc, name, fnc, required_args, optional_args, rest_arg, doc);
                    set_type(func, T_C_MACRO | T_DONT_EVAL_ARGS | T_UNHEAP); /* s7_make_function includes T_UNHEAP */
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    return(sym);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x403e5
movq %rax, %r15
movabsq $0x400000000000202e, %rax # imm = 0x400000000000202E
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa9f
movq %rax, %rbx
movq 0x110(%r14), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xce9d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: mark_c_proc_star
static void mark_c_proc_star(s7_pointer p)
    {
        set_mark(p);
        if (!c_func_has_simple_defaults(p))
        {
            s7_pointer arg;
            for (arg = c_function_call_args(p); is_pair(arg); arg = cdr(arg))
                gc_mark(car(arg));
        }
    }

// Assembly:
movq (%rdi), %rax
movq %rax, %rcx
btsq $0x3f, %rcx
movq %rcx, (%rdi)
btl $0x12, %eax
jb 0x40cff
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq 0x60(%rax), %rbx
cmpb $0x1, (%rbx)
jne 0x40cf8
leaq 0x10da92(%rip), %r14    # 0x14e770
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi)
js 0x40cef
movzbl (%rdi), %eax
callq *(%r14,%rax,8)
movq 0x10(%rbx), %rbx
cmpb $0x1, (%rbx)
je 0x40cde
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_safe_function_star
s7_pointer s7_make_safe_function_star(s7_scheme *sc, const char *name, s7_function fnc, const char *arglist, const char *doc)
                {
                    s7_pointer func;
                    func = s7_make_function_star(sc, name, fnc, arglist, doc);
                    set_type(func, typeflag(func) | T_SAFE_PROCEDURE);   /* don't step on the c_func_has_simple_defaults flag */
                    c_function_call_args(func) = permanent_list(sc, c_function_optional_args(func));
                    return(func);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x40937
movq %rax, %r14
orb $0x20, 0x2(%rax)
movq 0x20(%rax), %r15
movq 0x110(%rbx), %r12
testq %r15, %r15
jle 0x40d58
movabsq $0x4000000001000001, %r13 # imm = 0x4000000001000001
movq 0x110(%rbx), %rbp
movq %rbx, %rdi
callq 0xfa3b
movq %r13, (%rax)
movq %rbp, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, %r12
decq %r15
jne 0x40d34
jmp 0x40d5b
movq %r12, %rax
movq 0x8(%r14), %rcx
movq %rax, 0x60(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: define_function_star_1
static void define_function_star_1(s7_scheme *sc, const char *name, s7_function fnc, const char *arglist, const char *doc, bool safe, s7_pointer signature)
                {
                    s7_pointer func, sym;
                    if (safe)
                        func = s7_make_safe_function_star(sc, name, fnc, arglist, doc);
                    else func = s7_make_function_star(sc, name, fnc, arglist, doc);
                    sym = make_symbol(sc, name);
                    s7_define(sc, sc->nil, sym, func);
                    if (signature) c_function_signature(func) = signature;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsp), %r12
testl %r9d, %r9d
je 0x40da7
callq 0x40d00
jmp 0x40dac
callq 0x40937
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa9f
movq 0x110(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0xce9d
testq %r12, %r12
je 0x40ddc
movq 0x8(%r15), %rax
movq %r12, 0x38(%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: s7_documentation
const char *s7_documentation(s7_scheme *sc, s7_pointer x)
                {
                    s7_pointer val;
                    if (is_symbol(x))
                    {
                        if (is_keyword(x)) return(NULL);
                        if (symbol_has_help(x))
                            return(symbol_help(x));
                        x = s7_symbol_value(sc, x); /* this is needed by Snd */
                    }

                    if ((is_any_c_function(x)) ||
                            (is_c_macro(x)))
                        return((char *)c_function_documentation(x));

                    if (is_syntax(x))
                        return(syntax_documentation(x));

                    val = funclet_entry(sc, x, sc->local_documentation_symbol);
                    if ((val) && (is_string(val)))
                        return(string_value(val));

                    return(NULL);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0xa, (%rsi)
jne 0x40e34
testb $-0x80, 0x6(%rsi)
jne 0x40e6a
movq 0x8(%rsi), %rax
testb $0x20, 0x3(%rax)
jne 0x40e6e
movq %rbx, %rdi
callq 0xaa24
movq %rax, %rsi
movb (%rsi), %al
cmpb $0x2e, %al
jb 0x40e44
movq 0x8(%rsi), %rsi
addq $0x10, %rsi
jmp 0x40e76
cmpb $0x9, %al
jne 0x40e4e
addq $0x20, %rsi
jmp 0x40e76
movq 0x16c0(%rbx), %rdx
movq %rbx, %rdi
callq 0x40e7b
testq %rax, %rax
je 0x40e6a
movq %rax, %rsi
cmpb $0x13, (%rax)
je 0x40e3e
xorl %eax, %eax
jmp 0x40e79
movq 0x20(%rax), %rsi
addq $0x18, %rsi
movq (%rsi), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: funclet_entry
static s7_pointer funclet_entry(s7_scheme *sc, s7_pointer x, s7_pointer sym)
    {
        if ((has_closure_let(x)) && (is_let(closure_let(x))))
        {
            s7_pointer val;
            val = symbol_to_local_slot(sc, sym, closure_let(x));
            if ((!is_slot(val)) && (is_let(outlet(closure_let(x)))))
                val = symbol_to_local_slot(sc, sym, outlet(closure_let(x)));
            if (is_slot(val))
                return(slot_value(val));
        }
        return(NULL);
    }

// Assembly:
movzbl (%rsi), %eax
leaq 0x10da8b(%rip), %rcx    # 0x14e910
cmpb $0x1, (%rax,%rcx)
jne 0x40f08
movq 0x18(%rsi), %rax
cmpb $0x1c, (%rax)
jne 0x40f08
cmpq $0x0, 0x20(%rdx)
je 0x40eb9
movq 0x8(%rax), %rcx
testq %rcx, %rcx
sete %sil
je 0x40eb9
cmpq %rdx, 0x8(%rcx)
je 0x40eb4
movq 0x18(%rcx), %rcx
jmp 0x40e9f
testb %sil, %sil
je 0x40ec0
movq 0x128(%rdi), %rcx
cmpb $0x20, (%rcx)
je 0x40ef8
movq 0x10(%rax), %rax
cmpb $0x1c, (%rax)
jne 0x40ef8
cmpq $0x0, 0x20(%rdx)
je 0x40ef1
movq 0x8(%rax), %rcx
testq %rcx, %rcx
sete %al
je 0x40ef1
cmpq %rdx, 0x8(%rcx)
je 0x40eed
movq 0x18(%rcx), %rcx
jmp 0x40ed9
testb %al, %al
je 0x40ef8
movq 0x128(%rdi), %rcx
movb (%rcx), %dl
cmpb $0x20, %dl
jne 0x40f03
movq 0x10(%rcx), %rax
cmpb $0x20, %dl
je 0x40f0a
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_set_documentation
const char *s7_set_documentation(s7_scheme *sc, s7_pointer sym, const char *new_doc)
                {
                    if (is_keyword(sym)) return(NULL);
                    if (is_symbol(sym))
                    {
                        symbol_set_has_help(sym);
                        symbol_set_help(sym, copy_string(new_doc));
                    }
                    return(new_doc);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testb $-0x80, 0x6(%rsi)
jne 0x40f41
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0xa, (%rsi)
jne 0x40f43
movq 0x8(%r14), %rax
orq $0x20000000, (%rax)     # imm = 0x20000000
movq %rbx, %rdi
callq 0xd01f
movq 0x8(%r14), %rcx
movq 0x20(%rcx), %rcx
movq %rax, 0x18(%rcx)
jmp 0x40f43
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_help
const char *s7_help(s7_scheme *sc, s7_pointer obj)
                {
                    if (is_syntax(obj))
                        return(syntax_documentation(obj));

                    if (is_symbol(obj))
                    {
                        /* here look for name */
                        if (s7_documentation(sc, obj))
                            return(s7_documentation(sc, obj));
                        obj = s7_symbol_value(sc, obj);
                    }

                    if (is_procedure_or_macro(obj))
                        return(s7_documentation(sc, obj));

                    if (obj == sc->s7_let)
                        return("*s7* is a let that gives access to s7's internal state: e.g. (*s7* 'print-length)");

                    /* if is string, apropos? (can scan symbol table) */
                    return(NULL);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rsi), %eax
cmpl $0xa, %eax
je 0x40f6b
cmpl $0x9, %eax
jne 0x40f89
movq 0x20(%rbx), %rax
jmp 0x40fcc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40e10
testq %rax, %rax
jne 0x40fcc
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa24
movq %rax, %rbx
movzbl (%rbx), %eax
leaq 0x11339d(%rip), %rcx    # 0x154330
cmpb $0x0, (%rax,%rcx)
jne 0x40fa6
leaq 0x1133d0(%rip), %rcx    # 0x154370
cmpb $0x1, (%rax,%rcx)
jne 0x40fb8
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40e10
xorl %eax, %eax
cmpq 0x2150(%r14), %rbx
leaq 0xd21c9(%rip), %rcx     # 0x113191
cmoveq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_new_type_1
s7_int s7_new_type_1(s7_scheme *sc,
                        const char *name,
                        char *(*print)(s7_scheme *sc, void *value),
                        void (*gc_free)(void *value),
                        bool (*equal)(void *val1, void *val2),
                        void (*mark)(void *val),
                        s7_pointer (*ref)(s7_scheme *sc, s7_pointer obj, s7_pointer args), /* ignored */
                        s7_pointer (*set)(s7_scheme *sc, s7_pointer obj, s7_pointer args)) /* ignored */
                {
                    s7_int tag;
                    tag = s7_make_c_type(sc, name);
                    if (gc_free) sc->c_object_types[tag]->free = gc_free;
                    if (print) sc->c_object_types[tag]->print = print;
                    if (equal) sc->c_object_types[tag]->equal = equal;
                    if (mark) sc->c_object_types[tag]->mark = mark;
                    return(tag);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
callq 0x41559
testq %r13, %r13
je 0x4184f
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r13, 0x28(%rcx)
testq %r12, %r12
je 0x41863
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r12, 0x40(%rcx)
testq %r15, %r15
je 0x41877
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %r15, 0x38(%rcx)
testq %rbx, %rbx
je 0x4188b
movq 0x8d8(%r14), %rcx
movq (%rcx,%rax,8), %rcx
movq %rbx, 0x30(%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_c_object_value_checked
void *s7_c_object_value_checked(s7_pointer obj, s7_int type)
                {
                    if ((is_c_object(obj)) &&
                            (c_object_type(obj) == type))
                        return(c_object_value(obj));
                    return(NULL);
                }

// Assembly:
cmpb $0x14, (%rdi)
jne 0x418aa
cmpq %rsi, 0x8(%rdi)
jne 0x418aa
movq 0x10(%rdi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_make_c_object_with_let
s7_pointer s7_make_c_object_with_let(s7_scheme *sc, s7_int type, void *value, s7_pointer let)
                {
                    s7_pointer x;
                    new_cell(sc, x, sc->c_object_types[type]->outer_type);

                    /* c_object_info(x) = &(sc->c_object_types[type]); */
                    /* that won't work because c_object_types can move when it is realloc'd and the old stuff is freed by realloc
                     *   and since we're checking (for example) ref_2 existence as not null, we can't use a table of c_object_t's!
                     */
                    c_object_type(x) = type;
                    c_object_value(x) = value;
                    c_object_set_let(x, (let == sc->rootlet) ? sc->nil : let);
                    c_object_mark(x) = sc->c_object_types[type]->mark;
                    add_c_object(sc, x);
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x418da
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rbx
movq 0x8d8(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
movq %r13, 0x10(%rbx)
cmpq %r12, 0x150(%r14)
jne 0x4191a
movq 0x110(%r14), %r12
movq %r12, 0x18(%rbx)
movq 0x8d8(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rbx)
movq 0x768(%r14), %r14
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
jne 0x41959
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%r14)
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x9510
movq %rax, (%r14)
movq (%r14), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r14)
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_c_object_set_let
s7_pointer s7_c_object_set_let(s7_scheme *sc, s7_pointer obj, s7_pointer e)
                {
                    if ((!is_immutable(obj)) &&
                            (is_let(e)))
                        c_object_set_let(obj, (e == sc->rootlet) ? sc->nil : e);
                    return(e);
                }

// Assembly:
movq %rdx, %rax
testb $0x1, 0x3(%rsi)
jne 0x419af
cmpb $0x1c, (%rax)
jne 0x419af
movq %rax, %rcx
cmpq %rax, 0x150(%rdi)
jne 0x419ab
movq 0x110(%rdi), %rcx
movq %rcx, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_dilambda
s7_pointer s7_dilambda(s7_scheme *sc,
                        const char *name,
                        s7_pointer (*getter)(s7_scheme *sc, s7_pointer args),
                        s7_int get_req_args, s7_int get_opt_args,
                        s7_pointer (*setter)(s7_scheme *sc, s7_pointer args),
                        s7_int set_req_args, s7_int set_opt_args,
                        const char *documentation)
                {
                    s7_pointer get_func, set_func;
                    char *internal_set_name;
                    s7_int len;

                    if (!name) return(sc->F);
                    len = 16 + safe_strlen(name);
                    internal_set_name = (char *)malloc(len);
                    internal_set_name[0] = '\0';
                    catstrs_direct(internal_set_name, "[set-", name, "]", NULL);

                    get_func = s7_make_safe_function(sc, name, getter, get_req_args, get_opt_args, false, documentation);
                    s7_define(sc, sc->nil, make_symbol(sc, name), get_func);
                    set_func = s7_make_function(sc, internal_set_name, setter, set_req_args, set_opt_args, false, documentation);
                    c_function_set_setter(get_func, set_func);

                    return(get_func);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x419f4
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
cmpb $0x0, (%rsi)
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
je 0x41a00
movl $0xf, %eax
leaq 0x1(%rax), %rdi
cmpb $0x0, -0xf(%r15,%rax)
movq %rdi, %rax
jne 0x419e3
jmp 0x41a05
movq 0x120(%r14), %rbx
jmp 0x41aca
movl $0x10, %edi
callq 0x9480
movq %rax, %rbp
movb $0x0, (%rax)
leaq 0xd17cc(%rip), %rsi     # 0x1131e3
leaq 0xd1831(%rip), %rcx     # 0x11324f
xorl %r12d, %r12d
movq %rax, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xd1cb
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r13, %rcx
movq 0x8(%rsp), %r8
xorl %r9d, %r9d
callq 0x403e5
movq %rax, %rbx
orb $0x20, 0x2(%rax)
movq 0x110(%r14), %r13
cmpb $0x0, (%r15)
je 0x41a7d
movq $-0x1, %rax
leaq 0x1(%rax), %r12
cmpb $0x0, 0x1(%r15,%rax)
movq %r12, %rax
jne 0x41a6e
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9d9f
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xce9d
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %r8
xorl %r9d, %r9d
callq 0x403e5
movq 0x8(%rbx), %rcx
movq %rax, 0x30(%rcx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_typed_dilambda
s7_pointer s7_typed_dilambda(s7_scheme *sc,
                        const char *name,
                        s7_pointer (*getter)(s7_scheme *sc, s7_pointer args),
                        s7_int get_req_args, s7_int get_opt_args,
                        s7_pointer (*setter)(s7_scheme *sc, s7_pointer args),
                        s7_int set_req_args, s7_int set_opt_args,
                        const char *documentation,
                        s7_pointer get_sig, s7_pointer set_sig)
                {
                    s7_pointer get_func, set_func;
                    get_func = s7_dilambda(sc, name, getter, get_req_args, get_opt_args, setter, set_req_args, set_opt_args, documentation);
                    set_func = c_function_setter(get_func);
                    if (get_sig) c_function_signature(get_func) = get_sig;
                    if (set_sig) c_function_signature(set_func) = set_sig;
                    return(get_func);
                }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x50(%rsp), %rbx
movq 0x48(%rsp), %r14
movaps 0x30(%rsp), %xmm0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x419b0
movq 0x8(%rax), %rcx
testq %r14, %r14
je 0x41b12
movq %r14, 0x38(%rcx)
testq %rbx, %rbx
je 0x41b23
movq 0x30(%rcx), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, 0x38(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: numbers_are_eqv
static bool numbers_are_eqv(s7_pointer a, s7_pointer b)
                {
                    if (type(a) != type(b)) /* (eqv? 1 1.0) -> #f! */
                        return(false);

                    switch (type(a))
                    {
                        case T_INTEGER:
                            return((integer(a) == integer(b)));

                        case T_RATIO:
                            return((numerator(a) == numerator(b)) &&
                                    (denominator(a) == denominator(b)));

                        case T_REAL:
                            if (is_NaN(real(a)))
                                return(false);
                            return(real(a) == real(b));

                        case T_COMPLEX:
                            if ((is_NaN(real_part(a))) ||
                                    (is_NaN(imag_part(a))))
                                return(false);
                            return((real_part(a) == real_part(b)) &&
                                    (imag_part(a) == imag_part(b)));

                        default:
#if WITH_GMP
                            if ((is_big_number(a)) || (is_big_number(b))) /* this can happen if (member bignum ...) -> memv */
                                return(big_numbers_are_eqv(a, b));
#endif
                            break;
                    }
                    return(false);
                }

// Assembly:
movzbl (%rdi), %eax
cmpb (%rsi), %al
jne 0x42d12
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x42d12
leaq 0xcda2c(%rip), %rcx     # 0x1106d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x42d0e
movsd 0x8(%rdi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x42d12
cmpeqsd 0x8(%rsi), %xmm0
jmp 0x42cf3
movsd 0x8(%rdi), %xmm1
ucomisd %xmm1, %xmm1
jp 0x42d12
movsd 0x10(%rdi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x42d12
ucomisd 0x8(%rsi), %xmm1
jne 0x42d12
jp 0x42d12
cmpeqsd 0x10(%rsi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x42d12
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_string_fill_1
static s7_pointer g_string_fill_1(s7_scheme *sc, s7_pointer caller, s7_pointer args)
    {
        s7_pointer x, chr;
        s7_int start = 0, end;
        x = car(args);

        if (!is_string(x))
            return(method_or_bust(sc, x, caller, args, T_STRING, 1)); /* not two methods here */
        if (is_immutable_string(x))
            return(immutable_object_error(sc, set_elist_3(sc, immutable_error_string, caller, x)));

        chr = cadr(args);
        if (!s7_is_character(chr))
            return(method_or_bust(sc, chr, caller, args, T_CHARACTER, 2));

        end = string_length(x);
        if (!is_null(cddr(args)))
        {
            s7_pointer p;
            p = start_and_end(sc, caller, args, 3, &start, &end);
            if (p != sc->unused)
                return(p);
            if (start == end) return(chr);
        }
        if (end == 0) return(chr);

        if ((int)(character(chr)) == 0)
            memclr((void *)(string_value(x) + start), end - start);
        else local_memset((void *)(string_value(x) + start), (int32_t)character(chr), end - start);

        return(chr);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
movq $0x0, 0x10(%rsp)
movq 0x8(%rcx), %r15
cmpb $0x13, (%r15)
jne 0x4534e
testb $0x1, 0x3(%r15)
jne 0x45370
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rbx
cmpb $0x8, (%rbx)
jne 0x453ad
movq 0x8(%r15), %rsi
movq %rsi, 0x8(%rsp)
movq 0x10(%rax), %rax
cmpq 0x110(%r14), %rax
je 0x452e8
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movl $0x3, %ecx
callq 0xa0e7c
movq %rax, %r12
cmpq 0x140(%r14), %rax
cmoveq %rbx, %r12
jne 0x453f7
movq 0x8(%rsp), %rax
cmpq %rax, 0x10(%rsp)
je 0x453f7
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x453f4
movzbl 0x8(%rbx), %esi
movq 0x10(%rsp), %rax
movq 0x10(%r15), %r15
addq %rax, %r15
subq %rax, %r14
testq %rsi, %rsi
je 0x453c1
cmpq $0x8, %r14
jb 0x4533d
movq %r14, %rax
shrq $0x3, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rsi, %rcx
movq %rcx, (%r15)
addq $0x8, %r15
decq %rax
jne 0x4532d
andl $0x7, %r14d
testq %r14, %r14
je 0x453f4
movq %r15, %rdi
jmp 0x453ec
movq %r14, %rdi
movq %r15, %rsi
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf1ae
movq 0x10d5f1(%rip), %rax    # 0x152968
movq 0x6e8(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r15, 0x8(%rax)
movq 0x6e8(%r14), %rdx
movq 0xea8(%r14), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3b366
jmp 0x453f7
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %r8d
movl $0x2, %r9d
jmp 0x45360
cmpq $0x8, %r14
jb 0x453e2
movq %r14, %r12
andq $-0x8, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x9270
addq %r12, %r15
andl $0x7, %r14d
testq %r14, %r14
je 0x453f4
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9270
movq %rbx, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: copy_list
static inline s7_pointer copy_list(s7_scheme *sc, s7_pointer lst)
                {
                    s7_pointer p, tp, np;
                    if (!is_pair(lst)) return(sc->nil);
                    sc->u = lst;
                    tp = cons(sc, car(lst), sc->nil);
                    sc->y = tp;
                    for (p = cdr(lst), np = tp; is_pair(p); p = cdr(p), np = cdr(np))
                        set_cdr(np, cons(sc, car(p), sc->nil));
                    sc->y = sc->nil;
                    sc->u = sc->nil;
                    return(tp);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x45b7b
movq %rsi, %r15
movq %rsi, 0x4c8(%rbx)
movq 0x8(%rsi), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x45ad1
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r14
movq $0x200001, (%r14)       # imm = 0x200001
movq %r12, 0x8(%r14)
movq %r13, 0x10(%r14)
movq %r14, 0x4e8(%rbx)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
jne 0x45b64
movq %r14, %r12
movq 0x8(%r15), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x45b2d
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r13, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq %rax, 0x10(%r12)
movq 0x10(%r15), %r15
cmpb $0x1, (%r15)
movq %rax, %r12
je 0x45b0a
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
jmp 0x45b82
movq 0x110(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: type_name_string
static s7_pointer type_name_string(s7_scheme *sc, s7_pointer arg)
                {
                    if (type(arg) < NUM_TYPES)
                    {
                        s7_pointer p;
                        p = prepackaged_type_names[type(arg)]; /* these use INDEFINITE_ARTICLE */
                        if (is_string(p)) return(p);
                    }
                    return(s7_make_string_wrapper(sc, type_name(sc, arg, INDEFINITE_ARTICLE)));
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpq $0x33, %rax
ja 0x46209
leaq 0x10c860(%rip), %rcx    # 0x152a60
movq (%rcx,%rax,8), %rcx
cmpb $0x13, (%rcx)
je 0x4625e
movq %rbx, %rdi
movl $0x1, %edx
callq 0xa2d68
testq %rax, %rax
je 0x46237
cmpb $0x0, (%rax)
je 0x46237
movq $-0x1, %rcx
leaq 0x1(%rcx), %rdx
cmpb $0x0, 0x1(%rax,%rcx)
movq %rdx, %rcx
jne 0x46227
jmp 0x46239
xorl %edx, %edx
movq 0x820(%rbx), %rcx
movslq 0x7dc(%rbx), %rsi
movq (%rcx,%rsi,8), %rcx
incl %esi
andl $0x7, %esi
movl %esi, 0x7dc(%rbx)
movq %rax, 0x10(%rcx)
movq %rdx, 0x8(%rcx)
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_out_of_range_error
s7_pointer s7_out_of_range_error(s7_scheme *sc, const char *caller, s7_int arg_n, s7_pointer arg, const char *descr)
                {
                    if (arg_n > 0)
                        return(out_of_range_error_prepackaged(sc, wrap_string(sc, caller, safe_strlen(caller)), wrap_integer1(sc, arg_n), arg,
                                    wrap_string(sc, descr, safe_strlen(descr))));
                    return(simple_out_of_range_error_prepackaged(sc, wrap_string(sc, caller, safe_strlen(caller)),
                                arg, wrap_string(sc, descr, safe_strlen(descr))));
                }

// Assembly:
testq %rdx, %rdx
jle 0x46332
testq %rsi, %rsi
je 0x4628e
cmpb $0x0, (%rsi)
je 0x4628e
movq $-0x1, %r9
leaq 0x1(%r9), %rax
cmpb $0x0, 0x1(%rsi,%r9)
movq %rax, %r9
jne 0x4627d
jmp 0x46290
xorl %eax, %eax
movq 0x820(%rdi), %r9
movslq 0x7dc(%rdi), %r10
movq (%r9,%r10,8), %r9
incl %r10d
andl $0x7, %r10d
movl %r10d, 0x7dc(%rdi)
movq %rsi, 0x10(%r9)
movq %rax, 0x8(%r9)
movq 0x1f00(%rdi), %rax
movq %rdx, 0x8(%rax)
testq %r8, %r8
je 0x462e6
cmpb $0x0, (%r8)
je 0x462e6
movq $-0x1, %rax
leaq 0x1(%rax), %rsi
cmpb $0x0, 0x1(%r8,%rax)
movq %rsi, %rax
jne 0x462d5
jmp 0x462e8
xorl %esi, %esi
movq 0x1f00(%rdi), %rax
movq 0x820(%rdi), %rdx
movslq 0x7dc(%rdi), %r10
movq (%rdx,%r10,8), %rdx
incl %r10d
andl $0x7, %r10d
movl %r10d, 0x7dc(%rdi)
movq %r8, 0x10(%rdx)
movq %rsi, 0x8(%rdx)
leaq 0x1ee8(%rdi), %r8
movq 0x1ee8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %r9, 0x8(%rsi)
jmp 0x463d8
testq %rsi, %rsi
je 0x46353
cmpb $0x0, (%rsi)
je 0x46353
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%rsi,%rax)
movq %rdx, %rax
jne 0x46343
jmp 0x46355
xorl %edx, %edx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r9
movq (%rax,%r9,8), %rax
incl %r9d
andl $0x7, %r9d
movl %r9d, 0x7dc(%rdi)
movq %rsi, 0x10(%rax)
movq %rdx, 0x8(%rax)
testq %r8, %r8
je 0x463a0
cmpb $0x0, (%r8)
je 0x463a0
movq $-0x1, %rdx
leaq 0x1(%rdx), %rsi
cmpb $0x0, 0x1(%r8,%rdx)
movq %rsi, %rdx
jne 0x4638f
jmp 0x463a2
xorl %esi, %esi
movq 0x820(%rdi), %rdx
movslq 0x7dc(%rdi), %r9
movq (%rdx,%r9,8), %rdx
incl %r9d
andl $0x7, %r9d
movl %r9d, 0x7dc(%rdi)
movq %r8, 0x10(%rdx)
movq %rsi, 0x8(%rdx)
leaq 0x1ef8(%rdi), %r8
movq 0x1ef8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq (%r8), %rdx
jmp 0x3b366
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_call_with_catch
s7_pointer s7_call_with_catch(s7_scheme *sc, s7_pointer tag, s7_pointer body, s7_pointer error_handler)
                {
                    s7_pointer p, result;

                    new_cell(sc, p, T_CATCH);
                    catch_tag(p) = tag;
                    catch_goto_loc(p) = s7_stack_top(sc);
                    catch_op_loc(p) = (int32_t)(sc->op_stack_now - sc->op_stack);
                    catch_set_handler(p, error_handler);

                    push_stack(sc, OP_CATCH, error_handler, p);
                    result = s7_call(sc, body, sc->nil);
                    /* don't unstack here -- if error caught, catch has been popped off already */

                    return(result);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x90(%rdi), %rax
cmpq 0x98(%rdi), %rax
ja 0x46619
movq %r14, %rdi
callq 0xb389
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0x19, (%rax)
movq %r12, 0x18(%rax)
movq 0x50(%r14), %rcx
subq 0x48(%r14), %rcx
sarq $0x3, %rcx
movq %rcx, 0x8(%rax)
movq 0x68(%r14), %rcx
subq 0x60(%r14), %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
movq %rcx, 0x10(%rax)
movq %r15, 0x20(%rax)
movq 0x50(%r14), %rcx
movq %rax, (%rcx)
movq 0x8(%r14), %rax
movq 0x50(%r14), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%r14), %rax
movq %r15, 0x10(%rax)
movq 0x50(%r14), %rax
movq $0x1e0, 0x18(%rax)      # imm = 0x1E0
addq $0x20, 0x50(%r14)
movq 0x110(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x466aa
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: fill_error_location
static void fill_error_location(s7_scheme *sc)
                {
                    if (in_reader(sc))
                    {
                        integer(slot_value(sc->error_line)) = port_line_number(sc->input_port);
                        slot_set_value(sc->error_file, wrap_string(sc, port_filename(sc->input_port), port_filename_length(sc->input_port)));
                    }
                    else
                    {
                        integer(slot_value(sc->error_line)) = 0;
                        slot_set_value(sc->error_file, sc->F);
                    }
                }

// Assembly:
movq $-0x1d1, %rax           # imm = 0xFE2F
addq 0x18(%rdi), %rax
cmpq $0xb, %rax
ja 0x469a3
movq 0x170(%rdi), %rax
cmpb $0x23, (%rax)
jne 0x469a3
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movq 0x1b8(%rdi), %rcx
movq 0x10(%rcx), %rcx
movq %rax, 0x8(%rcx)
movq 0x170(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rax), %rdx
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rsi
movq (%rax,%rsi,8), %rax
incl %esi
andl $0x7, %esi
movl %esi, 0x7dc(%rdi)
movq %rcx, 0x10(%rax)
movq %rdx, 0x8(%rax)
jmp 0x469bd
movq 0x1b8(%rdi), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq 0x120(%rdi), %rax
movq 0x1c0(%rdi), %rcx
movq %rax, 0x10(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: object_to_truncated_string
static s7_pointer object_to_truncated_string(s7_scheme *sc, s7_pointer p, s7_int len)
                {
                    char *s;
                    s7_int s_len;
                    s7_pointer strp;
                    sc->objstr_max_len = len + 2;
                    strp = s7_object_to_string(sc, p, false);
                    s = string_value(strp);
                    sc->objstr_max_len = s7_int_max;
                    s_len = string_length(strp);
                    if (s_len > len)
                        truncate_string(s, len, P_DISPLAY);
                    return(strp);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x2(%rdx), %rax
movq %rax, 0x288(%rdi)
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x39f84
cmpb $0x0, 0x10c218(%rip)    # 0x152c08
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmoveq %r15, %rcx
movq 0x10(%rax), %rdx
movq %rcx, 0x288(%r14)
cmpq %rbx, 0x8(%rax)
jle 0x46a7a
leaq -0x4(%rbx), %rcx
movq %rbx, %rsi
shrq $0x3f, %rsi
addq %rbx, %rsi
sarq %rsi
cmpq %rsi, %rcx
jl 0x46a49
movq 0x1138a4(%rip), %rdi    # 0x15a2d0
addq %rdx, %rcx
leaq -0x3(%rbx), %r8
movzbl (%rcx), %r9d
cmpb $0x1, (%rdi,%r9)
je 0x46a6a
decq %rcx
decq %r8
cmpq %rsi, %r8
jg 0x46a33
cmpq $0x4, %rbx
jl 0x46a62
leaq (%rdx,%rbx), %rcx
decq %rcx
movw $0x2e2e, -0x3(%rcx)     # imm = 0x2E2E
movb $0x2e, -0x1(%rcx)
jmp 0x46a77
addq %rbx, %rdx
movq %rdx, %rcx
jmp 0x46a77
movw $0x2e2e, (%rcx)         # imm = 0x2E2E
movb $0x2e, 0x2(%rcx)
addq $0x3, %rcx
movb $0x0, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_function_star
s7_pointer s7_apply_function_star(s7_scheme *sc, s7_pointer fnc, s7_pointer args)
                {
                    TRACK(sc);
                    set_current_code(sc, history_cons(sc, fnc, args));

                    if (is_c_function_star(fnc))
                    {
                        sc->w = sc->args;
                        sc->z = sc->code;
                        sc->args = T_Pos(args);
                        sc->code = fnc;
                        apply_c_function_star(sc);
                        sc->args = sc->w;
                        sc->code = sc->z;
                        return(sc->value);
                    }
                    push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                    sc->code = fnc;
                    sc->args = (needs_copied_args(sc->code)) ? copy_list(sc, args) : args;
                    eval(sc, OP_APPLY);
                    return(sc->value);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rdi)
cmpb $0x2f, (%rsi)
jne 0x46b0c
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x4d8(%rbx)
movq %rax, 0x4f0(%rbx)
movq %r14, 0x10(%rbx)
movq %rsi, (%rbx)
movq 0x10(%rsi), %r14
movq %rbx, %rdi
callq 0x46c59
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, 0x20(%rbx)
movq 0x4d8(%rbx), %rcx
movq 0x4f0(%rbx), %rdx
movq %rcx, 0x10(%rbx)
movq %rdx, (%rbx)
jmp 0x46c4a
movq (%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1df, 0x18(%rax)      # imm = 0x1DF
addq $0x20, 0x50(%rbx)
movq %rsi, (%rbx)
testb $0x10, 0x3(%rsi)
jne 0x46b50
movq %r14, %r15
jmp 0x46c35
cmpb $0x1, (%r14)
jne 0x46c2e
movq %r14, 0x4c8(%rbx)
movq 0x8(%r14), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0x46b84
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r15
movq $0x200001, (%r15)       # imm = 0x200001
movq %r12, 0x8(%r15)
movq %r13, 0x10(%r15)
movq %r15, 0x4e8(%rbx)
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
jne 0x46c17
movq %r15, %r12
movq 0x8(%r14), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x46be0
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r13, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq %rax, 0x10(%r12)
movq 0x10(%r14), %r14
cmpb $0x1, (%r14)
movq %rax, %r12
je 0x46bbd
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
jmp 0x46c35
movq 0x110(%rbx), %r15
movq %r15, 0x10(%rbx)
movl $0x198, %esi            # imm = 0x198
movq %rbx, %rdi
callq 0x10b83
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq