LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq 0x90(%rsp), %rax
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x3bee8
movq 0x68(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x3bffd
movq 0x60(%rsp), %rdi
callq 0xa430
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x9480
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movb $0x0, (%rax)
movq 0x28(%rsp), %rdi
movq 0x60(%rsp), %rdx
leaq 0x1a5eb8(%rip), %rsi    # 0x1e1ddb
leaq 0x1a5f1d(%rip), %rcx    # 0x1e1e47
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x10540
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x90(%rsp), %rax
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x396a0
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xb400
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
movq 0x38(%rsp), %rcx
callq 0x10090
movq 0x68(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq 0x88(%rsp), %r8
movq 0x90(%rsp), %rax
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x39300
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x30(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r11
movq 0x68(%rsp), %r10
movq 0x70(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x3be90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x3c0bf
movq 0x78(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
cmpq $0x0, 0x80(%rsp)
je 0x3c0df
movq 0x80(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_is_dilambda
bool s7_is_dilambda(s7_pointer obj)
                {
                    switch (type(obj))
                    {
                        case T_MACRO:   case T_MACRO_STAR:
                        case T_BACRO:   case T_BACRO_STAR:
                        case T_CLOSURE: case T_CLOSURE_STAR:
                            return(is_any_procedure(closure_setter_or_map_list(obj))); /* type >= T_CLOSURE (excludes goto/continuation) */

                        case T_C_FUNCTION:
                        case T_C_ANY_ARGS_FUNCTION:
                        case T_C_OPT_ARGS_FUNCTION:
                        case T_C_RST_ARGS_FUNCTION:
                        case T_C_FUNCTION_STAR:
                            return(is_any_procedure(c_function_setter(obj)));

                        case T_C_MACRO:
                            return(is_any_procedure(c_macro_setter(obj)));
                    }
                    return(false);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rsp)
addl $-0x28, %eax
subl $0x6, %eax
jb 0x3c124
jmp 0x3c10b
movl -0x14(%rsp), %eax
subl $0x2e, %eax
je 0x3c15c
jmp 0x3c116
movl -0x14(%rsp), %eax
addl $-0x2f, %eax
subl $0x5, %eax
jb 0x3c13e
jmp 0x3c17a
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0x28, %eax
setge %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x3c17f
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movzbl (%rax), %eax
cmpl $0x28, %eax
setge %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x3c17f
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movzbl (%rax), %eax
cmpl $0x28, %eax
setge %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x3c17f
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: closure_arity_to_cons
static s7_pointer closure_arity_to_cons(s7_scheme *sc, s7_pointer x, s7_pointer x_args)
                {
                    /* x_args is unprocessed -- it is exactly the list as used in the closure[*] definition */
                    int32_t len;

                    if (is_symbol(x_args))                    /* any number of args is ok */
                        return(s7_cons(sc, small_int(0), max_arity));

                    if (closure_arity_unknown(x))
                        closure_set_arity(x, s7_list_length(sc, x_args));
                    len = closure_arity(x);
                    if (len < 0)                               /* dotted list => rest arg, (length '(a b . c)) is -2 */
                        return(s7_cons(sc, s7_make_integer(sc, -len), max_arity));
                    return(s7_cons(sc, s7_make_integer(sc, len), s7_make_integer(sc, len)));
                }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3ca82
movq 0x38(%rsp), %rdi
movq 0x1d9a14(%rip), %rsi    # 0x216480
movq 0x1df465(%rip), %rdx    # 0x21bed8
callq 0x2d720
movq %rax, 0x40(%rsp)
jmp 0x3cb38
movq 0x30(%rsp), %rax
cmpl $0x40000000, 0x28(%rax) # imm = 0x40000000
jne 0x3caa9
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x31900
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x30(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x3caf4
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
xorl %eax, %eax
subl 0x24(%rsp), %eax
movslq %eax, %rsi
callq 0x120f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x1df3f0(%rip), %rdx    # 0x21bed8
callq 0x2d720
movq %rax, 0x40(%rsp)
jmp 0x3cb38
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x120f0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x120f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2d720
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: closure_star_arity_to_cons
static s7_pointer closure_star_arity_to_cons(s7_scheme *sc, s7_pointer x, s7_pointer x_args)
                {
                    closure_star_arity_1(sc, x, x_args);

                    if (closure_arity(x) == -1)
                        return(s7_cons(sc, small_int(0), max_arity));
                    return(s7_cons(sc, small_int(0), s7_make_integer(sc, closure_arity(x))));
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xd9950
movq 0x20(%rsp), %rax
cmpl $-0x1, 0x28(%rax)
jne 0x3cba1
movq 0x28(%rsp), %rdi
movq 0x1d98f2(%rip), %rsi    # 0x216480
movq 0x1df343(%rip), %rdx    # 0x21bed8
callq 0x2d720
movq %rax, 0x30(%rsp)
jmp 0x3cbe1
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1d98ce(%rip), %rax    # 0x216480
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x28(%rax), %rsi
callq 0x120f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2d720
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: closure_is_aritable
static bool closure_is_aritable(s7_scheme *sc, s7_pointer x, s7_pointer x_args, int32_t args)
                {
                    /* x_args is unprocessed -- it is exactly the list as used in the closure definition */
                    s7_int len;

                    if (args == 0)
                        return(!is_pair(x_args));

                    if (is_symbol(x_args))                    /* any number of args is ok */
                        return(true);

                    len = closure_arity(x);
                    if (len == CLOSURE_ARITY_NOT_SET)
                    {
                        len = s7_list_length(sc, x_args);
                        closure_set_arity(x, len);
                    }
                    if (len < 0)                               /* dotted list => rest arg, (length '(a b . c)) is -2 */
                        return((-len) <= args);                  /*   so we have enough to take care of the required args */
                    return(args == len);                       /* in a normal lambda list, there are no other possibilities */
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x3d119
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
sete %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x3d19e
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3d12d
movb $0x1, 0x37(%rsp)
jmp 0x3d19e
movq 0x20(%rsp), %rax
movslq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x40000000, 0x8(%rsp)  # imm = 0x40000000
jne 0x3d169
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x31900
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x28(%rax)
cmpq $0x0, 0x8(%rsp)
jge 0x3d18b
xorl %eax, %eax
subq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
cmpq %rcx, %rax
setle %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x3d19e
movslq 0x14(%rsp), %rax
cmpq 0x8(%rsp), %rax
sete %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: closure_star_is_aritable
static bool closure_star_is_aritable(s7_scheme *sc, s7_pointer x, s7_pointer x_args, int32_t args)
                {
                    if (is_symbol(x_args))
                        return(true);

                    closure_star_arity_1(sc, x, x_args);
                    return((closure_arity(x) == -1) ||
                            (args <= closure_arity(x)));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3d1db
movb $0x1, 0x27(%rsp)
jmp 0x3d21d
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xd9950
movq 0x10(%rsp), %rcx
movb $0x1, %al
cmpl $-0x1, 0x28(%rcx)
movb %al, 0x3(%rsp)
je 0x3d213
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x28(%rcx), %eax
setle %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: slot_set_setter
static void slot_set_setter(s7_pointer p, s7_pointer val)
    {
        if ((type(val) == T_C_FUNCTION) &&
                (c_function_has_bool_setter(val)))
            slot_set_setter_1(p, c_function_bool_setter(val));
        else slot_set_setter_1(p, val);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jne 0x3de60
movq -0x10(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3de60
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x3de6e
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_is_eqv
bool s7_is_eqv(s7_pointer a, s7_pointer b)
                {
#if WITH_GMP
                    if ((is_big_number(a)) || (is_big_number(b)))
                        return(big_numbers_are_eqv(a, b));
#endif

                    if (type(a) != type(b))
                        return(false);

                    if ((a == b) && (!is_number(a)))                   /* if a is NaN, a == b doesn't mean (eqv? a b) */
                        return(true);                                    /* a == b means (let ((x "a")) (let ((y x)) (eqv? x y))) is #t */

                    if (s7_is_number(a))
                        return(numbers_are_eqv(a, b));

                    if (is_unspecified(a))                             /* types are the same so we know b is also unspecified */
                        return(true);

                    return(false);
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movq (%rsp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x3e6d7
movb $0x0, 0x17(%rsp)
jmp 0x3e73f
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jne 0x3e700
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1dbdad(%rip), %rax    # 0x21a4a0
testb $0x1, (%rax,%rcx)
jne 0x3e700
movb $0x1, 0x17(%rsp)
jmp 0x3e73f
movq 0x8(%rsp), %rdi
callq 0x11320
testb $0x1, %al
jne 0x3e710
jmp 0x3e726
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x3e750
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x3e73f
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x5, %eax
jne 0x3e73a
movb $0x1, 0x17(%rsp)
jmp 0x3e73f
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x442a1
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x4448f
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x4c8(%rax)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x442f5
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x4e8(%rax)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x44455
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x443d1
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
jmp 0x4437d
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x4e8(%rax)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x4c8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x34, %eax
jge 0x45030
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1d5584(%rip), %rax    # 0x21a590
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
jne 0x4502e
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x4505e
jmp 0x45030
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0xde490
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x145e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq %r8, 0x78(%rsp)
cmpq $0x0, 0x88(%rsp)
jle 0x45179
movq 0x98(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x90(%rsp), %rdi
callq 0xa430
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rax, %rdx
callq 0xb880
movq %rax, 0x60(%rsp)
movq 0x98(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x12430
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rdi
callq 0xa430
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq %rax, %rdx
callq 0xb880
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x70(%rsp), %rcx
movq %rax, %r8
callq 0x13880
movq %rax, 0xa0(%rsp)
jmp 0x45221
movq 0x98(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rax
movq %rax, (%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rdi
callq 0xa430
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xb880
movq %rax, 0x28(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
callq 0xa430
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0xb880
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
callq 0x45240
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x4576c
movq 0x30(%rsp), %rdi
callq 0xc670
movq 0x30(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x19, (%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rax
subq %rax, %rcx
sarq $0x3, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x60(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movslq %eax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1e0, %ecx            # imm = 0x1E0
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rdx
callq 0x45890
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x1d1, 0x18(%rax)      # imm = 0x1D1
jl 0x45ca2
movq (%rsp), %rax
cmpq $0x1dc, 0x18(%rax)      # imm = 0x1DC
jg 0x45ca2
movq (%rsp), %rax
movq 0x170(%rax), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x45ca2
movq (%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movl %eax, %ecx
movq (%rsp), %rax
movq 0x1b8(%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq (%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
callq 0xb880
movq %rax, %rcx
movq (%rsp), %rax
movq 0x1c0(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x45cd3
movq (%rsp), %rax
movq 0x1b8(%rax), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq 0x120(%rax), %rcx
movq (%rsp), %rax
movq 0x1c0(%rax), %rax
movq %rcx, 0x10(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: format_to_port
static s7_pointer format_to_port(s7_scheme *sc, s7_pointer port, const char *str, s7_pointer args, bool with_result, s7_int len)
    {
        if ((with_result) ||
                (port != sc->F))
            return(format_to_port_1(sc, port, str, args, NULL, with_result, true /* is_columnizing(str) */, len, NULL));
        /* is_columnizing on every call is much slower than ignoring the issue */
        return(sc->F);
    }

// Assembly:
subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %r9, 0x20(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x45d20
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x45d6a
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movb 0x2f(%rsp), %r9b
movq 0x20(%rsp), %rax
xorl %r8d, %r8d
andb $0x1, %r9b
movzbl %r9b, %r9d
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0xd2940
movq %rax, 0x50(%rsp)
jmp 0x45d7b
movq 0x48(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rcx
addq $0x2, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x288(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x2cd00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x1d4955(%rip), %rcx    # 0x21a738
movq 0x30(%rsp), %rax
movq %rcx, 0x288(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jle 0x45e1a
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0xde6a0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_call_with_location
s7_pointer s7_call_with_location(s7_scheme *sc, s7_pointer func, s7_pointer args, const char *caller, const char *file, s7_int line)
                {
                    s7_pointer result;

                    if (caller)
                    {
                        sc->s7_call_name = caller;
                        sc->s7_call_file = file;
                        sc->s7_call_line = line;
                    }
                    result = s7_call(sc, func, args);
                    if (caller)
                    {
                        sc->s7_call_name = NULL;
                        sc->s7_call_file = NULL;
                        sc->s7_call_line = -1;
                    }
                    return(result);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x46a9d
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x6b8(%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x6b0(%rax)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x698(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x45890
movq %rax, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x46aed
movq 0x30(%rsp), %rax
movq $0x0, 0x6b8(%rax)
movq 0x30(%rsp), %rax
movq $0x0, 0x6b0(%rax)
movq 0x30(%rsp), %rax
movq $-0x1, 0x698(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_quit
void s7_quit(s7_scheme *sc)
                {
                    sc->longjmp_ok = false;
                    pop_input_port(sc);
                    stack_reset(sc);
                    push_stack_op_let(sc, OP_EVAL_DONE);
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movb $0x0, 0x678(%rax)
movq (%rsp), %rdi
callq 0x274d0
movq (%rsp), %rdi
callq 0x46b80
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1df, %ecx            # imm = 0x1DF
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: opt_func
static void *opt_func(s7_pointer f, opt_func_t typ)
                {
                    if (is_c_function(f))
                    {
                        opt_funcs *p;
                        for (p = c_function_opt_data(f); p; p = p->next)
                            if (p->typ == typ)
                                return(p->func);
                    }
#if S7_DEBUGGING
                    else fprintf(stderr, "%s[%d]: 'f' is not a c_function\n", __func__, __LINE__);
#endif
                    return(NULL);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0x46d11
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x46d0f
movq -0x20(%rsp), %rax
movl (%rax), %eax
cmpl -0x14(%rsp), %eax
jne 0x46cfd
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x46d1a
jmp 0x46cff
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x46cd8
jmp 0x46d11
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_float_optimize
s7_float_function s7_float_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 (float_optimize(sc, expr))
                            return(opt_float_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 0x473d6
movq 0x8(%rsp), %rax
movl $0x0, 0x2258(%rax)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x473f0
testb $0x1, %al
jne 0x473c6
jmp 0x473d4
leaq 0x493(%rip), %rax       # 0x47860
movq %rax, 0x10(%rsp)
jmp 0x473df
jmp 0x473d6
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: s7_values
s7_pointer s7_values(s7_scheme *sc, s7_pointer args)
                {
#define H_values "(values obj ...) splices its arguments into whatever list holds it (its 'continuation')"
#define Q_values s7_make_circular_signature(sc, 1, 2, sc->values_symbol, sc->T)

                    if (is_null(args))         /* ((lambda () (let ((x 1)) (set! x (boolean? (values)))))) */
                        return(sc->no_value);
                    if (is_null(cdr(args)))
                        return(car(args));
                    set_needs_copied_args(args);
                    return(splice_in_values(sc, args));
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x47b42
movq 0x8(%rsp), %rax
movq 0x138(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x47b8b
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x47b67
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x47b8b
movq (%rsp), %rax
movq (%rax), %rcx
orq $0x10000000, %rcx       # imm = 0x10000000
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x28170
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: init_length_functions
static void init_length_functions(void)
                {
                    int32_t i;
                    for (i = 0; i < 256; i++) length_functions[i] = any_length;
                    length_functions[T_NIL]          = nil_length;
                    length_functions[T_PAIR]         = pair_length;
                    length_functions[T_VECTOR]       = v_length;
                    length_functions[T_FLOAT_VECTOR] = v_length;
                    length_functions[T_INT_VECTOR]   = v_length;
                    length_functions[T_STRING]       = str_length;
                    length_functions[T_BYTE_VECTOR]  = bv_length;
                    length_functions[T_ITERATOR]     = iter_length;
                    length_functions[T_HASH_TABLE]   = h_length;
                    length_functions[T_C_OBJECT]     = c_obj_length;
                    length_functions[T_LET]          = lt_length;
                    length_functions[T_CLOSURE]      = fnc_length;
                    length_functions[T_CLOSURE_STAR] = fnc_length;
                    length_functions[T_INPUT_PORT]   = ip_length;
                    length_functions[T_OUTPUT_PORT]  = op_length;
                }

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x100, -0x4(%rsp)      # imm = 0x100
jge 0x5ebd6
movslq -0x4(%rsp), %rcx
leaq 0x1c5b32(%rip), %rax    # 0x2246f0
leaq 0x152f7b(%rip), %rdx    # 0x1b1b40
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x5eba8
leaq 0x152f83(%rip), %rax    # 0x1b1b60
movq %rax, 0x1c5b1c(%rip)    # 0x224700
leaq 0x152f95(%rip), %rax    # 0x1b1b80
movq %rax, 0x1c5b06(%rip)    # 0x2246f8
leaq 0x153587(%rip), %rax    # 0x1b2180
movq %rax, 0x1c5b98(%rip)    # 0x224798
leaq 0x153579(%rip), %rax    # 0x1b2180
movq %rax, 0x1c5b9a(%rip)    # 0x2247a8
leaq 0x15356b(%rip), %rax    # 0x1b2180
movq %rax, 0x1c5b84(%rip)    # 0x2247a0
leaq 0x15362d(%rip), %rax    # 0x1b2250
movq %rax, 0x1c5b5e(%rip)    # 0x224788
leaq 0x1536ef(%rip), %rax    # 0x1b2320
movq %rax, 0x1c5b78(%rip)    # 0x2247b0
leaq 0x1537b1(%rip), %rax    # 0x1b23f0
movq %rax, 0x1c5b92(%rip)    # 0x2247d8
leaq 0x1537d3(%rip), %rax    # 0x1b2420
movq %rax, 0x1c5b74(%rip)    # 0x2247c8
leaq 0x153895(%rip), %rax    # 0x1b24f0
movq %rax, 0x1c5b2e(%rip)    # 0x224790
leaq 0x1539e7(%rip), %rax    # 0x1b2650
movq %rax, 0x1c5b60(%rip)    # 0x2247d0
leaq 0x153c09(%rip), %rax    # 0x1b2880
movq %rax, 0x1c5bb2(%rip)    # 0x224830
leaq 0x153bfb(%rip), %rax    # 0x1b2880
movq %rax, 0x1c5bac(%rip)    # 0x224838
leaq 0x153d0d(%rip), %rax    # 0x1b29a0
movq %rax, 0x1c5b6e(%rip)    # 0x224808
leaq 0x153f6f(%rip), %rax    # 0x1b2c10
movq %rax, 0x1c5b58(%rip)    # 0x224800
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: init_pows
static void init_pows(void)
    {
        int32_t i, j;
        for (i = 2; i < 17; i++)        /* radix between 2 and 16 */
            for (j = -MAX_POW; j < MAX_POW; j++) /* saved exponent between 0 and +/- MAX_POW */
                pepow[i][j + MAX_POW] = pow((double)i, (double)j);
    }

// Assembly:
pushq %rax
movl $0x2, 0x4(%rsp)
cmpl $0x11, 0x4(%rsp)
jge 0x5f078
movl $0xffffffc0, (%rsp)     # imm = 0xFFFFFFC0
cmpl $0x40, (%rsp)
jge 0x5f069
cvtsi2sdl 0x4(%rsp), %xmm0
cvtsi2sdl (%rsp), %xmm1
callq 0x9160
movslq 0x4(%rsp), %rcx
leaq 0x1be9b7(%rip), %rax    # 0x21da00
shlq $0xa, %rcx
addq %rcx, %rax
movl (%rsp), %ecx
addl $0x40, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x5f027
jmp 0x5f06b
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5f019
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: init_int_limits
static void init_int_limits(void)
    {
        int32_t i, top;
#if WITH_GMP
#define S7_LOG_LLONG_MAX 36.736800
#define S7_LOG_LONG_MAX  16.6355322
#else
        /* actually not safe = (log (- (expt 2 63) 1)) and (log (- (expt 2 31) 1)) (using 63 and 31 bits) */
#define S7_LOG_LLONG_MAX 43.668274
#define S7_LOG_LONG_MAX  21.487562
#endif

        top = sizeof(s7_int);
        s7_int32_max = (top == 8) ? S7_LONG_MAX : S7_SHORT_MAX;
        s7_int32_min = (top == 8) ? S7_LONG_MIN : S7_SHORT_MIN;
        s7_int_bits = (top == 8) ? 63 : 31;
        s7_int_digits = (top == 8) ? 18 : 8;

        s7_int_max = (top == 8) ? S7_LLONG_MAX : S7_LONG_MAX;
        s7_int_min = (top == 8) ? S7_LLONG_MIN : S7_LONG_MIN;

        s7_int_digits_by_radix[0] = 0;
        s7_int_digits_by_radix[1] = 0;

        for (i = 2; i < 17; i++)
            s7_int_digits_by_radix[i] = (int32_t)(floor(((top == 8) ? S7_LOG_LLONG_MAX : S7_LOG_LONG_MAX) / log((double)i)));
    }

// Assembly:
subq $0x28, %rsp
movl $0x8, 0x20(%rsp)
movl 0x20(%rsp), %edx
movl $0x7fff, %eax           # imm = 0x7FFF
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl $0x8, %edx
cmoveq %rcx, %rax
movl %eax, 0x1c5e8d(%rip)    # 0x224f34
movl 0x20(%rsp), %edx
movq $-0x8000, %rax          # imm = 0x8000
movq $-0x80000000, %rcx      # imm = 0x80000000
cmpl $0x8, %edx
cmoveq %rcx, %rax
movl %eax, 0x1c5f42(%rip)    # 0x225008
movl 0x20(%rsp), %edx
movl $0x1f, %eax
movl $0x3f, %ecx
cmpl $0x8, %edx
cmovel %ecx, %eax
movl %eax, 0x1bb6b0(%rip)    # 0x21a790
movl 0x20(%rsp), %edx
movl $0x8, %eax
movl $0x12, %ecx
cmpl $0x8, %edx
cmovel %ecx, %eax
movl %eax, 0x1c5f12(%rip)    # 0x22500c
movl 0x20(%rsp), %edx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpl $0x8, %edx
cmoveq %rcx, %rax
movq %rax, 0x1bb61d(%rip)    # 0x21a738
movl 0x20(%rsp), %edx
movq $-0x80000000, %rax      # imm = 0x80000000
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpl $0x8, %edx
cmoveq %rcx, %rax
movq %rax, 0x1bb41a(%rip)    # 0x21a558
movl $0x0, 0x1c2ce8(%rip)    # 0x221e30
movl $0x0, 0x1c2ce2(%rip)    # 0x221e34
movl $0x2, 0x24(%rsp)
cmpl $0x11, 0x24(%rsp)
jge 0x5f1de
movl 0x20(%rsp), %eax
movsd 0x18284b(%rip), %xmm0   # 0x1e19b8
movsd 0x18284b(%rip), %xmm1   # 0x1e19c0
movsd %xmm1, 0x10(%rsp)
cmpl $0x8, %eax
movsd %xmm0, 0x18(%rsp)
je 0x5f192
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm0
callq 0x92b0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x95f0
cvttsd2si %xmm0, %edx
movslq 0x24(%rsp), %rcx
leaq 0x1c2c65(%rip), %rax    # 0x221e30
movl %edx, (%rax,%rcx,4)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x5f15a
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: init_uppers
static void init_uppers(void)
    {
        int32_t i;
        for (i = 0; i < 256; i++)
        {
            uppers[i] = (uint8_t)toupper(i);
            lowers[i] = (uint8_t)tolower(i);
        }
    }

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
cmpl $0x100, 0x4(%rsp)       # imm = 0x100
jge 0x5f744
movl 0x4(%rsp), %edi
callq 0x90f0
movb %al, %dl
movslq 0x4(%rsp), %rcx
leaq 0x1c3056(%rip), %rax    # 0x222770
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %edi
callq 0x9460
movb %al, %dl
movslq 0x4(%rsp), %rcx
leaq 0x1c58ec(%rip), %rax    # 0x225020
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5f6f9
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: init_catchers
static void init_catchers(void)
                {
                    int32_t i;
                    for (i = 0; i < NUM_OPS; i++) catchers[i] = NULL;
                    catchers[OP_CATCH_ALL] =          catch_all_function;
                    catchers[OP_CATCH_2] =            catch_2_function;
                    catchers[OP_CATCH_1] =            catch_1_function;
                    catchers[OP_CATCH] =              catch_1_function;
                    catchers[OP_DYNAMIC_WIND] =       catch_dw_function;
                    catchers[OP_GET_OUTPUT_STRING] =  catch_out_function;
                    catchers[OP_UNWIND_OUTPUT] =      catch_out_function;
                    catchers[OP_UNWIND_INPUT] =       catch_in_function;
                    catchers[OP_READ_DONE] =          catch_read_function;      /* perhaps an error during (read) */
                    catchers[OP_EVAL_STRING] =        catch_eval_function;
                    catchers[OP_BARRIER] =            catch_barrier_function;
                    catchers[OP_DEACTIVATE_GOTO] =    catch_goto_function;
                    catchers[OP_LET_TEMP_DONE] =      catch_let_temporarily_function;
                    catchers[OP_LET_TEMP_UNWIND] =    catch_let_temp_unwind_function;
                    catchers[OP_LET_TEMP_S7_UNWIND] = catch_let_temp_s7_unwind_function;
                    catchers[OP_ERROR_HOOK_QUIT] =    catch_hook_function;
                }

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x357, -0x4(%rsp)      # imm = 0x357
jge 0x607c3
movslq -0x4(%rsp), %rcx
leaq 0x1bb732(%rip), %rax    # 0x21bee0
movq $0x0, (%rax,%rcx,8)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x60798
leaq 0x158046(%rip), %rax    # 0x1b8810
movq %rax, 0x1bc7cf(%rip)    # 0x21cfa0
leaq 0x158198(%rip), %rax    # 0x1b8970
movq %rax, 0x1bc7b9(%rip)    # 0x21cf98
leaq 0x1583ba(%rip), %rax    # 0x1b8ba0
movq %rax, 0x1bc7a3(%rip)    # 0x21cf90
leaq 0x1583ac(%rip), %rax    # 0x1b8ba0
movq %rax, 0x1bc5e5(%rip)    # 0x21cde0
leaq 0x158c0e(%rip), %rax    # 0x1b9410
movq %rax, 0x1bc5df(%rip)    # 0x21cde8
leaq 0x158d20(%rip), %rax    # 0x1b9530
movq %rax, 0x1bc701(%rip)    # 0x21cf18
leaq 0x158d12(%rip), %rax    # 0x1b9530
movq %rax, 0x1bc633(%rip)    # 0x21ce58
leaq 0x158da4(%rip), %rax    # 0x1b95d0
movq %rax, 0x1bc61d(%rip)    # 0x21ce50
leaq 0x158e06(%rip), %rax    # 0x1b9640
movq %rax, 0x1bc57f(%rip)    # 0x21cdc0
leaq 0x158e28(%rip), %rax    # 0x1b9670
movq %rax, 0x1bc709(%rip)    # 0x21cf58
leaq 0x158e6a(%rip), %rax    # 0x1b96c0
movq %rax, 0x1bc69b(%rip)    # 0x21cef8
leaq 0x158efc(%rip), %rax    # 0x1b9760
movq %rax, 0x1bc695(%rip)    # 0x21cf00
leaq 0x158f2e(%rip), %rax    # 0x1b97a0
movq %rax, 0x1bc437(%rip)    # 0x21ccb0
leaq 0x158fa0(%rip), %rax    # 0x1b9820
movq %rax, 0x1bc459(%rip)    # 0x21cce0
leaq 0x158ff2(%rip), %rax    # 0x1b9880
movq %rax, 0x1bc453(%rip)    # 0x21cce8
leaq 0x159074(%rip), %rax    # 0x1b9910
movq %rax, 0x1bc5bd(%rip)    # 0x21ce60
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: init_gc_caches
static void init_gc_caches(s7_scheme *sc)
    {
        sc->strings = make_gc_list();
        sc->gensyms = make_gc_list();
        sc->unknowns = make_gc_list();
        sc->vectors = make_gc_list();
        sc->multivectors = make_gc_list();
        sc->hash_tables = make_gc_list();
        sc->input_ports = make_gc_list();
        sc->input_string_ports = make_gc_list();
        sc->output_ports = make_gc_list();
        sc->continuations = make_gc_list();
        sc->c_objects = make_gc_list();
        sc->lambdas = make_gc_list();
        sc->weak_refs = make_gc_list();
        sc->lamlets = make_gc_list();
        sc->weak_hash_iterators = make_gc_list();
#if WITH_GMP
        sc->big_integers = make_gc_list();
        sc->big_ratios = make_gc_list();
        sc->big_reals = make_gc_list();
        sc->big_complexes = make_gc_list();
        sc->big_random_states = make_gc_list();
#endif

        /* slightly unrelated... */
        sc->setters_size = 4;
        sc->setters_loc = 0;
        sc->setters = (s7_pointer *)malloc(sc->setters_size * sizeof(s7_pointer));
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x738(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x778(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x780(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x740(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x790(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x770(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x748(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x758(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x750(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x760(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x768(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x788(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x798(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x7a8(%rax)
callq 0x1b9960
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x7a0(%rax)
movq (%rsp), %rax
movq $0x4, 0x7b8(%rax)
movq (%rsp), %rax
movq $0x0, 0x7c0(%rax)
movq (%rsp), %rax
movq 0x7b8(%rax), %rdi
shlq $0x3, %rdi
callq 0x9480
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x7b0(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)