LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_eq
static hash_entry_t *hash_eq(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    /* explicit eq? as hash equality func or (for example) symbols as keys */
                    hash_entry_t *x;
                    s7_int hash_mask, loc;

                    hash_mask = hash_table_mask(table);
                    loc = symbol_hmap(key) & hash_mask; /* hash_map_eq */

                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if (key == hash_entry_key(x))
                            return(x);

                    return(sc->unentry);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
sarq $0x8, %rax
andq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0x1c8a4c
movq -0x20(%rsp), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x1c8a3a
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1c8a5d
jmp 0x1c8a3c
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x1c8a17
movq -0x10(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_c_function
static hash_entry_t *hash_c_function(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    s7_int hash_mask, hash, loc;
                    s7_function f;

                    f = c_function_call(hash_table_procedures_checker(table));
                    hash_mask = hash_table_mask(table);
                    hash = hash_loc(sc, table, key);
                    loc = hash & hash_mask;

                    set_car(sc->t2_1, key);
                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if (hash_entry_raw_hash(x) == hash)
                        {
                            set_car(sc->t2_2, hash_entry_key(x));
                            if (is_true(sc, f(sc, sc->t2_1)))
                                return(x);
                        }
                    return(sc->unentry);
                }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq *%rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
andq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq 0x570(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1c8b85
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x1c8b73
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq 0x578(%rax), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rcx
movq 0x570(%rcx), %rsi
callq *%rax
movq 0x38(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x1c8b71
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1c8b96
jmp 0x1c8b73
jmp 0x1c8b75
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c8b10
movq 0x38(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_eqv
static hash_entry_t *hash_eqv(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    hash_entry_t *x;
                    s7_int hash_mask, loc;

                    hash_mask = hash_table_mask(table);
                    loc = hash_loc(sc, table, key) & hash_mask;

                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if (s7_is_eqv(key, hash_entry_key(x)))
                            return(x);

                    return(sc->unentry);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
andq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1c9194
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x3e6b0
testb $0x1, %al
jne 0x1c9176
jmp 0x1c9182
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1c91a5
jmp 0x1c9184
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1c9156
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_ci_char
static hash_entry_t *hash_ci_char(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (s7_is_character(key))
                    {
                        hash_entry_t *x;
                        s7_int hash_mask, loc;

                        hash_mask = hash_table_mask(table);
                        loc = hash_loc(sc, table, key) & hash_mask;

                        for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                            if (upper_character(key) == upper_character(hash_entry_key(x)))
                                return(x);
                    }
                    return(sc->unentry);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x1c9376
jmp 0x1c940a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *%rax
andq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1c9408
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x9(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1c93f6
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1c941b
jmp 0x1c93f8
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1c93c9
jmp 0x1c940a
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_ci_string
static hash_entry_t *hash_ci_string(s7_scheme *sc, s7_pointer table, s7_pointer key)
                {
                    if (is_string(key))
                    {
                        hash_entry_t *x;
                        s7_int hash, hash_mask;

                        hash_mask = hash_table_mask(table);
                        hash = hash_map_ci_string(sc, table, key);

                        for (x = hash_table_element(table, hash & hash_mask); x; x = hash_entry_next(x))
                            if (scheme_strequal_ci(key, hash_entry_key(x)))
                                return(x);
                    }
                    return(sc->unentry);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
jne 0x1c94d5
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x38700
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
andq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1c94d3
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x1c3d10
testb $0x1, %al
jne 0x1c94b5
jmp 0x1c94c1
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1c94e6
jmp 0x1c94c3
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1c9495
jmp 0x1c94d5
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: c_object_type_to_let
static s7_pointer c_object_type_to_let(s7_scheme *sc, s7_pointer cobj)
                {
                    static s7_pointer name_symbol = NULL;
                    if (!name_symbol)
                        name_symbol = make_symbol(sc, "name");
                    return(g_local_inlet(sc, 4,
                                name_symbol, c_object_scheme_name(sc, cobj),
                                sc->setter_symbol, (c_object_set(sc, cobj) != fallback_set) ? sc->c_object_set_function : sc->F));
                    /* should we make new wrappers every time this is called? or save the let somewhere and reuse it? */
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x5bcfa(%rip)     # 0x225200
jne 0x1c9520
movq 0x30(%rsp), %rdi
leaq 0x2a5fc(%rip), %rsi     # 0x1f3b10
callq 0xb400
movq %rax, 0x5bce0(%rip)     # 0x225200
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x5bccf(%rip), %rax     # 0x225200
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x14a0(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x8d8(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
leaq -0x18dd89(%rip), %rcx   # 0x3b800
cmpq %rcx, 0x50(%rax)
je 0x1c95a1
movq 0x30(%rsp), %rax
movq 0x1ed0(%rax), %rax
movq %rax, (%rsp)
jmp 0x1c95b1
movq 0x30(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movq (%rsp), %r9
movl $0x4, %esi
movb $0x0, %al
callq 0x1c4750
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_lambda
static s7_pointer s7_lambda(s7_scheme *sc, s7_function f, s7_int required_args, s7_int optional_args, bool rest_arg)
                {
                    /* same as s7_make_function but the new function is not global and permanent; it can be GC'd */
                    s7_pointer fnc;
                    block_t *block;
                    new_cell(sc, fnc, T_PAIR);  /* just a place-holder */
                    block = mallocate(sc, sizeof(c_proc_t));
                    fnc = make_function(sc, "#<unnamed-c-function>", f, required_args, optional_args, rest_arg, NULL, fnc, (c_proc_t *)block_data(block));
                    c_function_block(fnc) = block;
                    add_lambda(sc, fnc);
                    return(fnc);
                }

// Assembly:
subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x50(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x50(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c9625
movq 0x50(%rsp), %rdi
callq 0xc670
movq 0x50(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0x1, (%rax)
movq 0x50(%rsp), %rdi
movl $0x68, %esi
callq 0xaa80
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movb 0x37(%rsp), %r9b
movq 0x28(%rsp), %r10
movq 0x20(%rsp), %rax
movq (%rax), %rax
leaq 0x293ed(%rip), %rsi     # 0x1f2a82
xorl %r11d, %r11d
andb $0x1, %r9b
movzbl %r9b, %r9d
movq $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x39420
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x50(%rsp), %rax
movq 0x788(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x11230
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_bool_optimize
static s7_function s7_bool_optimize(s7_scheme *sc, s7_pointer expr)
                {
#if WITH_GMP
                    return(NULL);
#endif
                    if (setjmp(sc->opt_exit) == 0)
                    {
                        sc->pc = 0;
                        reset_opts(sc);
                        if (bool_optimize(sc, expr))
                            return(opt_bool_any);
                    }
                    return(NULL);
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
addq $0x2190, %rdi           # imm = 0x2190
callq 0x9350
cmpl $0x0, %eax
jne 0x1c9746
movq 0x8(%rsp), %rax
movl $0x0, 0x2258(%rax)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf83e0
testb $0x1, %al
jne 0x1c9736
jmp 0x1c9744
leaq 0x23(%rip), %rax        # 0x1c9760
movq %rax, 0x10(%rsp)
jmp 0x1c974f
jmp 0x1c9746
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: memv_number
static s7_pointer memv_number(s7_scheme *sc, s7_pointer obj, s7_pointer x)
                {
                    s7_pointer y;
                    y = x;
                    while (true)
                    {
                        LOOP_4(if ((s7_is_number(car(x))) && (numbers_are_eqv(obj, car(x)))) return(x); x = cdr(x); if (!is_pair(x)) return(sc->F));
                        y = cdr(y);
                        if (x == y) return(sc->F);
                    }
                    return(sc->F);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0x1c97ee
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11320
testb $0x1, %al
jne 0x1c9802
jmp 0x1c982a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x3e750
testb $0x1, %al
jne 0x1c981b
jmp 0x1c982a
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1c985b
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11320
testb $0x1, %al
jne 0x1c986f
jmp 0x1c9897
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x3e750
testb $0x1, %al
jne 0x1c9888
jmp 0x1c9897
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1c98c8
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11320
testb $0x1, %al
jne 0x1c98dc
jmp 0x1c9904
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x3e750
testb $0x1, %al
jne 0x1c98f5
jmp 0x1c9904
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1c9935
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11320
testb $0x1, %al
jne 0x1c9949
jmp 0x1c996e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x3e750
testb $0x1, %al
jne 0x1c9962
jmp 0x1c996e
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x1c999c
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
jmp 0x1c999e
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jne 0x1c99c8
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c99cd
jmp 0x1c97ec
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_table_reverse
static s7_pointer hash_table_reverse(s7_scheme *sc, s7_pointer old_hash)
                {
                    s7_int i, len;
                    s7_pointer new_hash;
                    hash_entry_t **old_lists;
                    s7_int gc_loc;

                    len = hash_table_mask(old_hash) + 1;
                    new_hash = s7_make_hash_table(sc, len);
                    gc_loc = s7_gc_protect_1(sc, new_hash);

                    /* I don't think the original hash functions can make any sense in general, so ignore them */
                    old_lists = hash_table_elements(old_hash);
                    for (i = 0; i < len; i++)
                    {
                        hash_entry_t *x;
                        for (x = old_lists[i]; x; x = hash_entry_next(x))
                            s7_hash_table_set(sc, new_hash, hash_entry_value(x), hash_entry_key(x));
                    }
                    s7_gc_unprotect_at(sc, gc_loc);
                    return(new_hash);
                }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2a440
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9cb0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jge 0x1c9db8
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1c9da6
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
callq 0x2a7b0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1c9d6e
jmp 0x1c9da8
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1c9d4f
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9f60
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: vector_sort_lt
static int32_t vector_sort_lt(const void *v1, const void *v2, void *arg) /* for qsort_r */
                {
                    s7_pointer s1, s2;
                    s1 = (*(s7_pointer *)v1);
                    s2 = (*(s7_pointer *)v2);
                    if ((is_t_integer(s1)) && (is_t_integer(s2)))
                        return((integer(s1) < integer(s2)) ? -1 : 1);
                    return((lt_b_7pp((s7_scheme *)arg, s1, s2)) ? -1 : 1);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1c9e8f
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xb, %eax
jne 0x1c9e8f
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovll %ecx, %eax
movl %eax, 0x34(%rsp)
jmp 0x1c9eb9
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xbb410
movb %al, %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: vector_car_sort
static int32_t vector_car_sort(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    s7_pointer a, b;
                    a = (*(s7_pointer *)v1);
                    b = (*(s7_pointer *)v2);
                    a = (is_pair(a)) ? car(a) : g_car(sc, set_plist_1(sc, a));
                    b = (is_pair(b)) ? car(b) : g_car(sc, set_plist_1(sc, b));
                    return(((*(sc->sort_f))(sc, a, b)) ? -1 : 1);
                }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c9f84
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c9faf
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x35ea0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x8e3b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c9fd6
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1ca001
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x35ea0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8e3b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0xad8(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq *%rax
movb %al, %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: vector_cdr_sort
static int32_t vector_cdr_sort(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    s7_pointer a, b;
                    a = (*(s7_pointer *)v1);
                    b = (*(s7_pointer *)v2);
                    a = (is_pair(a)) ? cdr(a) : g_cdr(sc, set_plist_1(sc, a));
                    b = (is_pair(b)) ? cdr(b) : g_cdr(sc, set_plist_1(sc, b));
                    return(((*(sc->sort_f))(sc, a, b)) ? -1 : 1);
                }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1ca094
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1ca0bf
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x35ea0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x8e420
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1ca0e6
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1ca111
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x35ea0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8e420
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0xad8(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq *%rax
movb %al, %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: opt_bool_sort_p
static int32_t opt_bool_sort_p(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    slot_set_value(sc->sort_v1, (*(s7_pointer *)v1));
                    slot_set_value(sc->sort_v2, (*(s7_pointer *)v2));
                    sc->pc = 0;
                    return((sc->opts[0]->v[7].fp(sc->opts[0]) == sc->F) ? 1 : -1);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xab8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xac0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x2258(%rax)
movq 0x8(%rsp), %rax
movq 0x2260(%rax), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x2260(%rcx), %rdi
callq *%rax
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x120(%rax), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: opt_bool_sort_0
static int32_t opt_bool_sort_0(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    slot_set_value(sc->sort_v1, (*(s7_pointer *)v1)); /* first slot in curlet */
                    slot_set_value(sc->sort_v2, (*(s7_pointer *)v2)); /* second slot in curlet */
                    return((sc->sort_fb(sc->sort_o)) ? -1 : 1);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xab8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xac0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0xae8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0xae0(%rcx), %rdi
callq *%rax
movb %al, %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: opt_begin_bool_sort_b2
static int32_t opt_begin_bool_sort_b2(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    opt_info *o;
                    slot_set_value(sc->sort_v1, (*(s7_pointer *)v1));
                    slot_set_value(sc->sort_v2, (*(s7_pointer *)v2));
                    sc->pc = 0;
                    o = sc->opts[0];
                    o->v[0].fp(o);
                    o = sc->opts[++sc->pc];
                    return((o->v[0].fb(o)) ? -1 : 1);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xab8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xac0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x2258(%rax)
movq 0x8(%rsp), %rax
movq 0x2260(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x8(%rsp), %rdx
movl 0x2258(%rdx), %ecx
addl $0x1, %ecx
movl %ecx, 0x2258(%rdx)
movslq %ecx, %rcx
movq 0x2260(%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rdi
callq *%rax
movb %al, %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: opt_begin_bool_sort_b
static int32_t opt_begin_bool_sort_b(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    s7_int i;
                    opt_info *o;
                    slot_set_value(sc->sort_v1, (*(s7_pointer *)v1));
                    slot_set_value(sc->sort_v2, (*(s7_pointer *)v2));
                    sc->pc = -1;
                    for (i = 0; i < sc->sort_body_len - 1; i++)
                    {
                        o = sc->opts[++sc->pc];
                        o->v[0].fp(o);
                    }
                    o = sc->opts[++sc->pc];
                    return((o->v[0].fb(o)) ? -1 : 1);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq 0xab8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq 0xac0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x2258(%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0xad0(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x1ca497
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rdx
movl 0x2258(%rdx), %ecx
addl $0x1, %ecx
movl %ecx, 0x2258(%rdx)
movslq %ecx, %rcx
movq 0x2260(%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1ca435
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rdx
movl 0x2258(%rdx), %ecx
addl $0x1, %ecx
movl %ecx, 0x2258(%rdx)
movslq %ecx, %rcx
movq 0x2260(%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movb %al, %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: opt_begin_bool_sort_p
static int32_t opt_begin_bool_sort_p(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    s7_int i;
                    opt_info *o;
                    slot_set_value(sc->sort_v1, (*(s7_pointer *)v1));
                    slot_set_value(sc->sort_v2, (*(s7_pointer *)v2));
                    sc->pc = -1;
                    for (i = 0; i < sc->sort_body_len - 1; i++)
                    {
                        o = sc->opts[++sc->pc];
                        o->v[0].fp(o);
                    }
                    o = sc->opts[++sc->pc];
                    return((o->v[0].fp(o) != sc->F) ? -1 : 1);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq 0xab8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq 0xac0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x2258(%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0xad0(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x1ca5b7
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rdx
movl 0x2258(%rdx), %ecx
addl $0x1, %ecx
movl %ecx, 0x2258(%rdx)
movslq %ecx, %rcx
movq 0x2260(%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1ca555
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rdx
movl 0x2258(%rdx), %ecx
addl $0x1, %ecx
movl %ecx, 0x2258(%rdx)
movslq %ecx, %rcx
movq 0x2260(%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: closure_sort
static int32_t closure_sort(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    slot_set_value(sc->sort_v1, (*(s7_pointer *)v1));
                    slot_set_value(sc->sort_v2, (*(s7_pointer *)v2));
                    push_stack(sc, OP_EVAL_DONE, sc->sort_body, sc->code);
                    sc->code = sc->sort_body; /* this should be ok because we checked in advance that it is a safe closure (no sort! for example) */
                    eval(sc, sc->sort_op);
                    return((sc->value != sc->F) ? -1 : 1);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xab8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xac0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0xaa8(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1df, %ecx            # imm = 0x1DF
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0xaa8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xac8(%rax), %rsi
callq 0x163d0
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x120(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: closure_sort_begin
static int32_t closure_sort_begin(const void *v1, const void *v2, void *arg)
                {
                    s7_scheme *sc = (s7_scheme *)arg;
                    slot_set_value(sc->sort_v1, (*(s7_pointer *)v1));
                    slot_set_value(sc->sort_v2, (*(s7_pointer *)v2));
                    push_stack(sc, OP_EVAL_DONE, sc->sort_body, sc->code);
                    push_stack_no_args(sc, OP_BEGIN1, sc->sort_begin);
                    sc->code = sc->sort_body;
                    eval(sc, sc->sort_op);
                    return((sc->value != sc->F) ? -1 : 1);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xab8(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0xac0(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0xaa8(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1df, %ecx            # imm = 0x1DF
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
jmp 0x1ca7e5
movq 0x8(%rsp), %rax
movq 0xab0(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1a1, %ecx            # imm = 0x1A1
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0xaa8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xac8(%rax), %rsi
callq 0x163d0
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x120(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: int_less_2
static int32_t int_less_2(const void *f1, const void *f2)
                {
                    s7_pointer p1, p2;
                    p1 = (*((s7_pointer *)f1));
                    p2 = (*((s7_pointer *)f2));
                    if (integer(p1) < integer(p2)) return(-1);
                    if (integer(p1) > integer(p2)) return(1);
                    return(0);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x1caa72
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1caa98
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x1caa90
movl $0x1, -0x4(%rsp)
jmp 0x1caa98
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: dbl_less_2
static int32_t dbl_less_2(const void *f1, const void *f2)
                {
                    s7_pointer p1, p2;
                    p1 = (*((s7_pointer *)f1));
                    p2 = (*((s7_pointer *)f2));
                    if (real(p1) < real(p2)) return(-1);
                    if (real(p1) > real(p2)) return(1);
                    return(0);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq -0x28(%rsp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1cab18
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1cab40
movq -0x20(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x28(%rsp), %rax
ucomisd 0x8(%rax), %xmm0
jbe 0x1cab38
movl $0x1, -0x4(%rsp)
jmp 0x1cab40
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: chr_less_2
static int32_t chr_less_2(const void *f1, const void *f2)
                {
                    s7_pointer p1, p2;
                    p1 = (*((s7_pointer *)f1));
                    p2 = (*((s7_pointer *)f2));
                    if (character(p1) < character(p2)) return(-1);
                    if (character(p1) > character(p2)) return(1);
                    return(0);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movzbl 0x8(%rax), %eax
movq -0x28(%rsp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1cac34
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1cac5c
movq -0x20(%rsp), %rax
movzbl 0x8(%rax), %eax
movq -0x28(%rsp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jle 0x1cac54
movl $0x1, -0x4(%rsp)
jmp 0x1cac5c
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_table_append
static s7_pointer hash_table_append(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer new_hash, p;
                    new_hash = s7_make_hash_table(sc, sc->default_hash_table_length);
                    push_stack_no_let(sc, OP_GC_PROTECT, args, new_hash);
                    for (p = args; is_pair(p); p = cdr(p))
                        s7_copy_1(sc, sc->append_symbol, set_plist_2(sc, car(p), new_hash));
                    set_plist_2(sc, sc->nil, sc->nil);
                    unstack(sc);
                    return(new_hash);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x270(%rax), %rsi
callq 0x2a440
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1, %ecx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1cc25b
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0xbb8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0x36f70
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x3e9e0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x1cc1f9
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rdx
callq 0x36f70
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: let_append
static s7_pointer let_append(s7_scheme *sc, s7_pointer args)
                {
                    s7_pointer new_let, p, e;
                    e = car(args);
                    push_stack_no_let_no_code(sc, OP_GC_PROTECT, args);
                    check_method_unstacking(sc, e, sc->append_symbol, args);
                    new_let = new_frame_in_env(sc, sc->nil);
                    for (p = args; is_pair(p); p = cdr(p))
                        s7_copy_1(sc, sc->append_symbol, set_plist_2(sc, car(p), new_let));
                    set_plist_2(sc, sc->nil, sc->nil);
                    unstack(sc);
                    return(new_let);
                }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1, %ecx
movq %rcx, 0x18(%rax)
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x38(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1cc3b0
movq 0x58(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1cc3b0
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x9a10
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x58(%rsp), %rax
movq 0xbb8(%rax), %rdx
callq 0x98d0
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x1cc3b0
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x44270
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq %rax, 0x60(%rsp)
jmp 0x1cc474
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x110(%rax), %rsi
callq 0xc53b0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1cc437
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq 0xbb8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x48(%rsp), %rdx
callq 0x36f70
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x3e9e0
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x1cc3d5
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x110(%rax), %rsi
movq 0x58(%rsp), %rax
movq 0x110(%rax), %rdx
callq 0x36f70
movq 0x58(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: sequence_length
static s7_int sequence_length(s7_scheme *sc, s7_pointer lst)
                {
                    switch (type(lst))
                    {
                        case T_PAIR:
                            {
                                s7_int len;
                                len = s7_list_length(sc, lst);
                                if (len == 0) return(-1);
                                return(len);
                            }
                        case T_NIL:         return(0);
                        case T_BYTE_VECTOR:
                        case T_INT_VECTOR:
                        case T_FLOAT_VECTOR:
                        case T_VECTOR:      return(vector_length(lst));
                        case T_STRING:      return(string_length(lst));
                        case T_HASH_TABLE:  return(hash_table_entries(lst));
                        case T_LET:         return(let_length(sc, lst));
                        case T_C_OBJECT:
                                            {
                                                s7_pointer x;
                                                x = c_object_length(sc, lst);
                                                if (s7_is_integer(x))
                                                    return(s7_integer(x));
                                            }
                    }
                    return(-1);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x1b, %eax
ja 0x1cc585
movq 0x8(%rsp), %rax
leaq 0x14c94(%rip), %rcx     # 0x1e1148
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x31900
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1cc4e7
movq $-0x1, 0x30(%rsp)
jmp 0x1cc58e
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1cc58e
movq $0x0, 0x30(%rsp)
jmp 0x1cc58e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1cc58e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1cc58e
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1cc58e
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xda510
movq %rax, 0x30(%rsp)
jmp 0x1cc58e
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xd7520
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x1cc572
jmp 0x1cc583
movq 0x10(%rsp), %rdi
callq 0x10790
movq %rax, 0x30(%rsp)
jmp 0x1cc58e
jmp 0x1cc585
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)