LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: catch_dw_function
static bool catch_dw_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    s7_pointer x;
                    x = stack_code(sc->stack, i);
                    if (dynamic_wind_state(x) == DWIND_BODY)
                    {
                        dynamic_wind_state(x) = DWIND_FINISH;    /* make sure an uncaught error in the exit thunk doesn't cause us to loop */
                        if (dynamic_wind_out(x) != sc->F)
                        {
                            push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                            sc->code = dynamic_wind_out(x);
                            sc->args = sc->nil;
                            eval(sc, OP_APPLY);                  /* I guess this means no call/cc out of the exit thunk in an error-catching context */
                        }
                    }
                    return(false);
                }

// 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 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
subq $0x3, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x1b951e
movq 0x8(%rsp), %rax
movl $0x2, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x120(%rcx), %rax
je 0x1b951c
jmp 0x1b9484
movq 0x30(%rsp), %rax
movq (%rax), %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 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1df, %ecx            # imm = 0x1DF
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rdi
movl $0x198, %esi            # imm = 0x198
callq 0x163d0
jmp 0x1b951e
xorl %eax, %eax
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: catch_out_function
static bool catch_out_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    s7_pointer x;
                    x = stack_code(sc->stack, i);                /* "code" = port that we opened */
                    s7_close_output_port(sc, x);
                    x = stack_args(sc->stack, i);                /* "args" = port that we shadowed, if not #<unused> */
                    if (x != sc->unused)
                        sc->output_port = x;
                    return(false);
                }

// 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 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
subq $0x3, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14f80
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x140(%rcx), %rax
je 0x1b95be
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x188(%rax)
xorl %eax, %eax
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: catch_barrier_function
static bool catch_barrier_function(s7_scheme *sc, s7_int i, s7_pointer type, s7_pointer info, bool *reset_hook)
                {
                    if (is_input_port(stack_args(sc->stack, i)))      /* (eval-string "'(1 .)") */
                    {
                        if (sc->input_port == stack_args(sc->stack, i))
                            pop_input_port(sc);
                        s7_close_input_port(sc, stack_args(sc->stack, i));
                    }
                    return(false);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x1b9754
movq 0x20(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x18(%rsp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x1b9730
movq 0x20(%rsp), %rdi
callq 0x274d0
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14ce0
xorl %eax, %eax
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_gc_list
static gc_list *make_gc_list(void)
    {
        gc_list *gp;
#define INIT_GC_CACHE_SIZE 4
        gp = (gc_list *)malloc(sizeof(gc_list));
        gp->size = INIT_GC_CACHE_SIZE;
        gp->loc = 0;
        gp->list = (s7_pointer *)malloc(gp->size * sizeof(s7_pointer));
        return(gp);
    }

// Assembly:
pushq %rax
movl $0x18, %edi
callq 0x9480
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x4, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x9480
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: stdout_write_string
static void stdout_write_string(s7_scheme *sc, const char *str, s7_int len, s7_pointer port)
    {
        if (str[len] == '\0')
            fputs(str, stdout);
        else
        {
            s7_int i;
            for (i = 0; i < len; i++)
                fputc(str[i], stdout);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1b9a81
movq 0x18(%rsp), %rdi
movq 0x5b559(%rip), %rax     # 0x214fd0
movq (%rax), %rsi
callq 0x9250
jmp 0x1b9ac0
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jge 0x1b9abe
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movsbl (%rax,%rcx), %edi
movq 0x5b528(%rip), %rax     # 0x214fd0
movq (%rax), %rsi
callq 0x9300
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1b9a89
jmp 0x1b9ac0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: stderr_write_string
static void stderr_write_string(s7_scheme *sc, const char *str, s7_int len, s7_pointer port)
    {
        if (str[len] == '\0')
            fputs(str, stderr);
        else
        {
            s7_int i;
            for (i = 0; i < len; i++)
                fputc(str[i], stderr);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1b9b91
movq 0x18(%rsp), %rdi
movq 0x5b471(%rip), %rax     # 0x214ff8
movq (%rax), %rsi
callq 0x9250
jmp 0x1b9bd0
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jge 0x1b9bce
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movsbl (%rax,%rcx), %edi
movq 0x5b440(%rip), %rax     # 0x214ff8
movq (%rax), %rsi
callq 0x9300
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1b9b99
jmp 0x1b9bd0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: stdin_read_line
static s7_pointer stdin_read_line(s7_scheme *sc, s7_pointer port, bool with_eol, bool copied)
    {
        if (!sc->read_line_buf)
        {
            sc->read_line_buf_size = 1024;
            sc->read_line_buf = (char *)malloc(sc->read_line_buf_size);
        }

        if (fgets(sc->read_line_buf, sc->read_line_buf_size, stdin))
            return(s7_make_string(sc, sc->read_line_buf)); /* fgets adds the trailing '\0' */
        return(make_string_with_length(sc, NULL, 0));
    }

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
andb $0x1, %cl
movb %cl, 0xf(%rsp)
andb $0x1, %al
movb %al, 0xe(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x4b8(%rax)
jne 0x1b9c8e
movq 0x18(%rsp), %rax
movq $0x400, 0x4c0(%rax) # imm = 0x400
movq 0x18(%rsp), %rax
movq 0x4c0(%rax), %rdi
callq 0x9480
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x4b8(%rax)
movq 0x18(%rsp), %rax
movq 0x4b8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x4c0(%rax), %rax
movl %eax, %esi
movq 0x5b329(%rip), %rax     # 0x214fd8
movq (%rax), %rdx
callq 0x9330
cmpq $0x0, %rax
je 0x1b9cda
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x4b8(%rax), %rsi
callq 0x14630
movq %rax, 0x20(%rsp)
jmp 0x1b9cf0
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x144d0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_string_to_symbol_1
static inline s7_pointer g_string_to_symbol_1(s7_scheme *sc, s7_pointer str, s7_pointer caller)
    {
        if (is_string(str))
        {
            if (string_length(str) > 0)
                return(make_symbol_with_length(sc, string_value(str), string_length(str)));
            return(simple_wrong_type_argument_with_type(sc, caller, str, wrap_string(sc, "a non-null string", 17)));
            /* currently if the string has an embedded null, it marks the end of the new symbol name. */
        }
        return(method_or_bust_one_arg(sc, str, caller, list_1(sc, str), T_STRING));
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
jne 0x1b9e65
movq 0x60(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jle 0x1b9df6
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0xa2b0
movq %rax, 0x70(%rsp)
jmp 0x1b9f39
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0x140(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x39626(%rip), %rsi     # 0x1f345b
movl $0x11, %edx
callq 0xb880
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %rax, %r8
callq 0x14a60
movq %rax, 0x70(%rsp)
jmp 0x1b9f39
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1b9ec1
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, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rcx
movl $0x13, %r8d
callq 0xcfd30
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: find_dynamic_value
static s7_pointer find_dynamic_value(s7_scheme *sc, s7_pointer x, s7_pointer sym, int64_t *id)
    {
        for (; symbol_id(sym) < let_id(x); x = outlet(x));

        if (let_id(x) == symbol_id(sym))
        {
            (*id) = let_id(x);
            return(slot_value(local_slot(sym)));
        }
        for (; (is_let(x)) && (let_id(x) > (*id)); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == sym)
                {
                    (*id) = let_id(x);
                    return(slot_value(y));
                }
        }
        return(sc->unused);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jge 0x1ba6da
jmp 0x1ba6ca
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x1ba6b4
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x1ba716
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1ba7cc
jmp 0x1ba718
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x1c, %ecx
movb %al, -0x31(%rsp)
jne 0x1ba743
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
setg %al
movb %al, -0x31(%rsp)
movb -0x31(%rsp), %al
testb $0x1, %al
jne 0x1ba74d
jmp 0x1ba7bb
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x30(%rsp)
je 0x1ba7a6
movq -0x30(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rsp), %rax
jne 0x1ba794
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1ba7cc
jmp 0x1ba796
movq -0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rsp)
jmp 0x1ba75b
jmp 0x1ba7a8
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x1ba718
movq -0x10(%rsp), %rax
movq 0x140(%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: c_port_line_number
static s7_pointer c_port_line_number(s7_scheme *sc, s7_pointer x)
    {
        if ((!(is_input_port(x))) ||
                (port_is_closed(x)))
            return(method_or_bust_with_type_one_arg(sc, x, sc->port_line_number_symbol, list_1(sc, x), an_input_port_string));
        return(make_integer(sc, port_line_number(x)));
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x1ba8be
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x1ba9a1
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0x13f0(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1ba922
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, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x48(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movq 0x5fd9e(%rip), %r8      # 0x21a730
callq 0x1ba7e0
movq %rax, 0x70(%rsp)
jmp 0x1baa62
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %eax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1ba9d9
movq 0x38(%rsp), %rcx
leaq 0x5bab1(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x1baa4f
jmp 0x1ba9db
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1ba9ff
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, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0xb, (%rax)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%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: c_port_filename
static s7_pointer c_port_filename(s7_scheme *sc, s7_pointer x)
    {
        if (((is_input_port(x)) ||
                    (is_output_port(x))) &&
                (!port_is_closed(x)))
        {
            if (port_filename(x))
                return(make_string_with_length(sc, port_filename(x), port_filename_length(x))); /* not wrapper here! */
            return(make_string_with_length(sc, "", 0));
            /* otherwise (eval-string (port-filename)) and (string->symbol (port-filename)) segfault */
        }
        return(method_or_bust_with_type_one_arg(sc, x, sc->port_filename_symbol, list_1(sc, x), an_open_port_string));
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
je 0x1baa98
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x1bab04
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x1bab04
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x1baae5
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdx
callq 0x144d0
movq %rax, 0x50(%rsp)
jmp 0x1babe2
movq 0x48(%rsp), %rdi
leaq 0x399c8(%rip), %rsi     # 0x1f44b9
xorl %eax, %eax
movl %eax, %edx
callq 0x144d0
movq %rax, 0x50(%rsp)
jmp 0x1babe2
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x13e8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bab68
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x672a8(%rip), %r8      # 0x221e80
callq 0x1ba7e0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: open_and_protect_input_string
static inline s7_pointer open_and_protect_input_string(s7_scheme *sc, s7_pointer str)
    {
        s7_pointer p;
        p = open_input_string(sc, string_value(str), string_length(str));
        port_gc_loc(p) = s7_gc_protect_1(sc, str);
        port_needs_unprotect(p) = true;
        return(p);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x156e0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9cb0
movq %rax, %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x1(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: input_port_if_not_loading
static s7_pointer input_port_if_not_loading(s7_scheme *sc)
    {
        s7_pointer port;
        port = sc->input_port;
        if (is_loader_port(port)) /* this flag is turned off by the reader macros, so we aren't in that context */
        {
            int32_t c;
            c = port_read_white_space(port)(sc, port);
            if (c > 0)            /* we can get either EOF or NULL at the end */
            {
                backchar(c, port);
                return(NULL);
            }
            return(sc->standard_input);
        }
        return(port);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x170(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x1bace5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x1bacd2
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rsi
movsbl %al, %edi
callq 0x15ec0
movq $0x0, 0x20(%rsp)
jmp 0x1bacef
movq 0x18(%rsp), %rax
movq 0x1c8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1bacef
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: call_with_input
static s7_pointer call_with_input(s7_scheme *sc, s7_pointer port, s7_pointer args)
    {
        s7_pointer p;
        p = cadr(args);
        port_original_input_string(port) = car(args);
        push_stack(sc, OP_UNWIND_INPUT, sc->input_port, port);
        push_stack(sc, OP_APPLY, list_1(sc, port), p);
        return(sc->F);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x40(%rax)
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x170(%rax), %rcx
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1ee, %ecx            # imm = 0x1EE
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
jmp 0x1bada0
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bae06
movq 0x40(%rsp), %rdi
callq 0xc670
movq 0x40(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x198, %ecx            # imm = 0x198
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x40(%rsp), %rax
movq 0x120(%rax), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: with_input
static s7_pointer with_input(s7_scheme *sc, s7_pointer port, s7_pointer args)
    {
        s7_pointer old_input_port, p;
        old_input_port = sc->input_port;
        sc->input_port = port;
        port_original_input_string(port) = car(args);
        push_stack(sc, OP_UNWIND_INPUT, old_input_port, port);
        p = cadr(args);
        push_stack(sc, OP_APPLY, sc->nil, p);
        return(sc->F);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x170(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x170(%rax)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rsp), %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 -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1ee, %ecx            # imm = 0x1EE
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %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 0x110(%rax), %rcx
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x198, %ecx            # imm = 0x198
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rsp), %rax
movq 0x120(%rax), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: c_complex
static s7_pointer c_complex(s7_scheme *sc, s7_double rl, s7_double im)
    {
        /* same as s7_make_complex, but assumes im is not 0.0 */
        s7_pointer x;
        new_cell(sc, x, T_COMPLEX);
        set_real_part(x, rl);
        set_imag_part(x, im);
        return(x);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bb039
movq 0x20(%rsp), %rdi
callq 0xc670
movq 0x20(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0xe, (%rax)
movsd 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: my_hypot
static double my_hypot(double x, double y)
    {
        /* according to callgrind, this is much faster than libc's hypot */
        if (x == 0.0) return(fabs(y));
        if (y == 0.0) return(fabs(x));
        if (x == y) return(1.414213562373095 * fabs(x));
        if ((is_NaN(x)) || (is_NaN(y))) return(NAN);
        return(sqrt(x * x + y * y));
    }

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1bb49b
jp 0x1bb49b
movsd (%rsp), %xmm0
movaps 0x26614(%rip), %xmm1    # 0x1e1aa0
pand %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x1bb553
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1bb4c7
jp 0x1bb4c7
movsd 0x8(%rsp), %xmm0
movaps 0x265e8(%rip), %xmm1    # 0x1e1aa0
pand %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x1bb553
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jne 0x1bb4fb
jp 0x1bb4fb
movsd 0x8(%rsp), %xmm1
movaps 0x265bd(%rip), %xmm0    # 0x1e1aa0
pand %xmm0, %xmm1
movsd 0x265a9(%rip), %xmm0    # 0x1e1a98
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x1bb553
movsd 0x8(%rsp), %xmm0
callq 0x13860
testb $0x1, %al
jne 0x1bb51a
movsd (%rsp), %xmm0
callq 0x13860
testb $0x1, %al
jne 0x1bb51a
jmp 0x1bb52a
movsd 0x264a6(%rip), %xmm0    # 0x1e19c8
movsd %xmm0, 0x10(%rsp)
jmp 0x1bb553
movsd 0x8(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
mulsd (%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x9690
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_is_positive
static bool s7_is_positive(s7_pointer x)
    {
        switch (type(x))
        {
            case T_INTEGER:     return(integer(x) > 0);
            case T_RATIO:       return(numerator(x) > 0);
#if WITH_GMP
            case T_BIG_INTEGER: return(mpz_cmp_ui(big_integer(x), 0) > 0);
            case T_BIG_RATIO:   return(mpq_cmp_ui(big_ratio(x), 0, 1) > 0);
            case T_BIG_REAL:    return(mpfr_cmp_ui(big_real(x), 0) > 0);
#endif
            default:            return(real(x) > 0.0);
        }
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rsp)
subl $0xb, %eax
je 0x1bb5b3
jmp 0x1bb5a8
movl -0x14(%rsp), %eax
subl $0xc, %eax
je 0x1bb5c8
jmp 0x1bb5dd
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
setg %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1bb5f7
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
setg %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1bb5f7
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_is_zero
static bool s7_is_zero(s7_pointer x)
    {
        switch (type(x))
        {
            case T_INTEGER:     return(integer(x) == 0);
            case T_REAL:        return(real(x) == 0.0);
#if WITH_GMP
            case T_BIG_INTEGER: return(mpz_cmp_ui(big_integer(x), 0) == 0);
            case T_BIG_RATIO:   return(mpz_cmp_ui(mpq_numref(big_ratio(x)), 0) == 0);   /* a big_ratio can be zero! */
            case T_BIG_REAL:    return(mpfr_zero_p(big_real(x)));
#endif
            default:            return(false); /* ratios and complex numbers here are already collapsed into integers and reals */
        }
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rsp)
subl $0xb, %eax
je 0x1bb683
jmp 0x1bb678
movl -0x14(%rsp), %eax
subl $0xd, %eax
je 0x1bb698
jmp 0x1bb6b9
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1bb6be
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1bb6be
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: int_pow_ok
static bool int_pow_ok(s7_int x, s7_int y)
    {
        if (s7_int_bits > 31)
            return((y < 63) &&
                    (nth_roots[y] >= s7_int_abs(x)));
        return((y < 31) &&
                (int_nth_roots[y] >= s7_int_abs(x)));
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpl $0x1f, 0x5e84f(%rip)    # 0x21a790
jle 0x1bbfb7
xorl %eax, %eax
cmpq $0x3f, -0x18(%rsp)
movb %al, -0x39(%rsp)
jge 0x1bbfab
movq -0x18(%rsp), %rcx
leaq 0x25703(%rip), %rax     # 0x1e1660
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
jl 0x1bbf84
movq -0x20(%rsp), %rax
movq %rax, -0x50(%rsp)
jmp 0x1bbf90
xorl %eax, %eax
subq -0x20(%rsp), %rax
movq %rax, -0x50(%rsp)
movq -0x48(%rsp), %rax
movq -0x50(%rsp), %rcx
movq %rcx, -0x28(%rsp)
cmpq -0x28(%rsp), %rax
setge %al
movb %al, -0x39(%rsp)
movb -0x39(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x1bc029
xorl %eax, %eax
cmpq $0x1f, -0x18(%rsp)
movb %al, -0x51(%rsp)
jge 0x1bc01f
movq -0x18(%rsp), %rcx
leaq 0x2588f(%rip), %rax     # 0x1e1860
movq (%rax,%rcx,8), %rax
movq %rax, -0x60(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x30(%rsp)
jl 0x1bbff8
movq -0x30(%rsp), %rax
movq %rax, -0x68(%rsp)
jmp 0x1bc004
xorl %eax, %eax
subq -0x30(%rsp), %rax
movq %rax, -0x68(%rsp)
movq -0x60(%rsp), %rax
movq -0x68(%rsp), %rcx
movq %rcx, -0x38(%rsp)
cmpq -0x38(%rsp), %rax
setge %al
movb %al, -0x51(%rsp)
movb -0x51(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: int_to_int
static s7_int int_to_int(s7_int x, s7_int n)
    {
        /* from GSL */
        s7_int value = 1;
        do {
            if (n & 1) value *= x;
            n >>= 1;
#if HAVE_OVERFLOW_CHECKS
            if (multiply_overflow(x, x, &x))
                break;
#else
            x *= x;
#endif
        } while (n);
        return(value);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x1, -0x18(%rsp)
movq -0x10(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x1bc062
movq -0x8(%rsp), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
sarq %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rcx
imulq -0x8(%rsp), %rcx
seto %al
movq %rcx, -0x8(%rsp)
testb $0x1, %al
jne 0x1bc088
jmp 0x1bc08a
jmp 0x1bc094
jmp 0x1bc08c
cmpq $0x0, -0x10(%rsp)
jne 0x1bc043
movq -0x18(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_truncate
static s7_pointer s7_truncate(s7_scheme *sc, s7_pointer caller, s7_double xf)   /* can't use "truncate" -- it's in unistd.h */
    {
        if ((xf > s7_int_max) ||
                (xf < s7_int_min))
            return(simple_out_of_range(sc, caller, wrap_real(sc, xf), its_too_large_string));

        if (xf > 0.0)
            return(make_integer(sc, (s7_int)floor(xf)));
        return(make_integer(sc, (s7_int)ceil(xf)));
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movsd 0x68(%rsp), %xmm0
cvtsi2sdq 0x5e672(%rip), %xmm1 # 0x21a738
ucomisd %xmm1, %xmm0
ja 0x1bc0e1
movsd 0x68(%rsp), %xmm1
cvtsi2sdq 0x5e47d(%rip), %xmm0 # 0x21a558
ucomisd %xmm1, %xmm0
jbe 0x1bc12f
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rdi
movsd 0x68(%rsp), %xmm0
callq 0x1bc2f0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
movq 0x5e453(%rip), %rcx     # 0x21a570
callq 0x45240
movq %rax, 0x80(%rsp)
jmp 0x1bc2dd
movsd 0x68(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1bc212
movsd 0x68(%rsp), %xmm0
callq 0x95f0
cvttsd2si %xmm0, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1bc17f
movq 0x60(%rsp), %rcx
leaq 0x5a30c(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x1bc1f6
jmp 0x1bc181
movq 0x78(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x78(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bc1a5
movq 0x78(%rsp), %rdi
callq 0xc670
movq 0x78(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0xb, (%rax)
movq 0x60(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x1bc2dd
movsd 0x68(%rsp), %xmm0
callq 0x96c0
cvttsd2si %xmm0, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1bc24f
movq 0x40(%rsp), %rcx
leaq 0x5a23c(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x1bc2c6
jmp 0x1bc251
movq 0x78(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x78(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bc275
movq 0x78(%rsp), %rdi
callq 0xc670
movq 0x78(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0xb, (%rax)
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: r5rs_round
static s7_double r5rs_round(s7_double x)
    {
        s7_double fl, ce, dfl, dce;

        fl = floor(x);
        ce = ceil(x);
        dfl = x - fl;
        dce = ce - x;

        if (dfl > dce) return(ce);
        if (dfl < dce) return(fl);
        if (fmod(fl, 2.0) == 0.0) return(fl);
        return(ce);
    }

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x95f0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x96c0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0x1bc38c
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1bc3e4
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1bc3ac
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1bc3e4
movsd 0x20(%rsp), %xmm0
movsd 0x2562e(%rip), %xmm1    # 0x1e19e8
callq 0x92c0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1bc3d8
jp 0x1bc3d8
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1bc3e4
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: c_gcd
static s7_int c_gcd(s7_int u, s7_int v)
    {
        s7_int a, b;

        if ((u == s7_int_min) || (v == s7_int_min))
        {
            /* can't take abs of these (below) so do it by hand */
            s7_int divisor = 1;
            if (u == v) return(u);
            while (((u & 1) == 0) && ((v & 1) == 0))
            {
                u /= 2;
                v /= 2;
                divisor *= 2;
            }
            return(divisor);
        }

        a = s7_int_abs(u);
        b = s7_int_abs(v);
        /* there are faster gcd algorithms but does it ever matter? */
        while (b != 0)
        {
            s7_int temp;
            temp = a % b;
            a = b;
            b = temp;
        }
        /* if (a < 0) return(-a); */ /* why this? */
        return(a);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq 0x5e152(%rip), %rax     # 0x21a558
je 0x1bc41a
movq -0x18(%rsp), %rax
cmpq 0x5e144(%rip), %rax     # 0x21a558
jne 0x1bc4b9
movq $0x1, -0x30(%rsp)
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
jne 0x1bc43e
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1bc56e
jmp 0x1bc440
movq -0x10(%rsp), %rcx
andq $0x1, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x59(%rsp)
jne 0x1bc469
movq -0x18(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x59(%rsp)
movb -0x59(%rsp), %al
testb $0x1, %al
jne 0x1bc473
jmp 0x1bc4aa
movq -0x10(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rsp)
movq -0x30(%rsp), %rax
shlq %rax
movq %rax, -0x30(%rsp)
jmp 0x1bc440
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1bc56e
movq -0x10(%rsp), %rax
movq %rax, -0x38(%rsp)
cmpq $0x0, -0x38(%rsp)
jl 0x1bc4d7
movq -0x38(%rsp), %rax
movq %rax, -0x68(%rsp)
jmp 0x1bc4e3
xorl %eax, %eax
subq -0x38(%rsp), %rax
movq %rax, -0x68(%rsp)
movq -0x68(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
cmpq $0x0, -0x48(%rsp)
jl 0x1bc515
movq -0x48(%rsp), %rax
movq %rax, -0x70(%rsp)
jmp 0x1bc521
xorl %eax, %eax
subq -0x48(%rsp), %rax
movq %rax, -0x70(%rsp)
movq -0x70(%rsp), %rax
movq %rax, -0x50(%rsp)
movq -0x50(%rsp), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0x1bc564
movq -0x20(%rsp), %rax
cqto
idivq -0x28(%rsp)
movq %rdx, -0x58(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x58(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x1bc535
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_rational_via_method
static bool is_rational_via_method(s7_scheme *sc, s7_pointer p) /* used in gmp as well as below */
    {
        if (s7_is_rational(p))
            return(true);
        if (has_active_methods(sc, p))
        {
            s7_pointer f;
            f = find_method(sc, find_let(sc, p), sc->is_rational_symbol);
            if (f != sc->undefined)
                return(is_true(sc, s7_apply_function(sc, f, cons(sc, p, sc->nil))));
        }
        return(false);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11380
testb $0x1, %al
jne 0x1bc59e
jmp 0x1bc5a8
movb $0x1, 0x57(%rsp)
jmp 0x1bc6f8
movq 0x40(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1bc6f3
movq 0x48(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1bc6f3
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rax
movq 0x1178(%rax), %rdx
callq 0x98d0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x1bc6f1
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bc672
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xda50
movq 0x48(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0x1bc6f8
jmp 0x1bc6f3
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: multiply_method_or_bust
static s7_pointer multiply_method_or_bust(s7_scheme *sc, s7_pointer obj, s7_pointer caller, s7_pointer args, s7_pointer typ, int32_t num)
    {
        if (has_active_methods(sc, obj))
            return(find_and_apply_method(sc, find_let(sc, obj), sc->multiply_symbol, args));
        if (num == 0)
            return(simple_wrong_type_argument_with_type(sc, caller, obj, typ));
        return(wrong_type_argument_with_type(sc, caller, num, obj, typ));
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movl %r9d, 0x44(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1beb95
movq 0x68(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1beb95
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x9a10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x68(%rsp), %rax
movq 0x1358(%rax), %rdx
movq 0x50(%rsp), %rcx
callq 0xc84f0
movq %rax, 0x70(%rsp)
jmp 0x1becc6
cmpl $0x0, 0x44(%rsp)
jne 0x1bebcf
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rax
movq 0x140(%rax), %rcx
movq 0x48(%rsp), %r8
callq 0x14a60
movq %rax, 0x70(%rsp)
jmp 0x1becc6
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movslq 0x44(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1bec18
movq 0x38(%rsp), %rcx
leaq 0x57872(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x1bec8e
jmp 0x1bec1a
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bec3e
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, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0xb, (%rax)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x48(%rsp), %r9
callq 0xc560
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_invert
static s7_pointer s7_invert(s7_scheme *sc, s7_pointer p)      /* s7_ to be consistent... */
    {
        switch (type(p))
        {
            case T_INTEGER: return(make_simple_ratio(sc, 1, integer(p)));           /* a already checked, not 0 */
            case T_RATIO:   return(make_simple_ratio(sc, denominator(p), numerator(p)));
            case T_REAL:    return(make_real(sc, 1.0 / real(p)));
            case T_COMPLEX: return(complex_invert(sc, p));
            default:        return(wrong_type_argument_with_type(sc, sc->divide_symbol, 1, p, a_number_string));
        }
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movzbl (%rax), %eax
addl $-0xb, %eax
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
subl $0x3, %eax
ja 0x1bee03
movq 0x20(%rsp), %rax
leaq 0x223e3(%rip), %rcx     # 0x1e10e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdx
movl $0x1, %esi
callq 0x1bb0a0
movq %rax, 0x70(%rsp)
jmp 0x1bef05
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x1bb0a0
movq %rax, 0x70(%rsp)
jmp 0x1bef05
movq 0x60(%rsp), %rax
movsd 0x22c05(%rip), %xmm0    # 0x1e1968
divsd 0x8(%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bed92
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, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq $0xd, (%rax)
movsd 0x50(%rsp), %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x1bef05
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x1c0e40
movq %rax, 0x70(%rsp)
jmp 0x1bef05
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq 0xe88(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x1, 0x40(%rsp)
movq 0x40(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1bee53
movq 0x40(%rsp), %rcx
leaq 0x57638(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x1beeca
jmp 0x1bee55
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1bee79
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, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0xb, (%rax)
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x65ff5(%rip), %r9      # 0x224ef0
callq 0xc560
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nop