LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_unwind_output
static void op_unwind_output(s7_scheme *sc)
                {
                    bool is_file;
                    is_file = is_file_port(sc->code);

                    if ((is_output_port(sc->code)) &&
                            (!port_is_closed(sc->code)))
                        s7_close_output_port(sc, sc->code); /* may call fflush */

                    if (((is_output_port(sc->args)) &&
                                (!port_is_closed(sc->args))) ||
                            (sc->args == sc->F))
                        sc->output_port = sc->args;

                    if ((is_file) &&
                            (is_multiple_value(sc->value)))
                        sc->value = splice_in_values(sc, multiple_value(sc->value));
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
sete %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x157886
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x157886
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x14f80
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x1578aa
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
je 0x1578c1
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x1578d6
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x188(%rax)
testb $0x1, 0xf(%rsp)
je 0x157912
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movzwl (%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x157912
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x28170
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_unwind_input
static void op_unwind_input(s7_scheme *sc)
                {
                    /* sc->code is an input port */
                    if (!port_is_closed(sc->code))
                        s7_close_input_port(sc, sc->code);

                    if ((is_input_port(sc->args)) &&
                            (!port_is_closed(sc->args)))
                        sc->input_port = sc->args;

                    if (is_multiple_value(sc->value))
                        sc->value = splice_in_values(sc, multiple_value(sc->value));
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x157946
movq (%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x14ce0
movq (%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x23, %eax
jne 0x15797b
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x2(%rax)
jne 0x15797b
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x170(%rax)
movq (%rsp), %rax
movq 0x20(%rax), %rax
movzwl (%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x1579ac
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x28170
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_with_let_unchecked
static bool op_with_let_unchecked(s7_scheme *sc)
                {
                    set_current_code(sc, sc->code);
                    sc->code = cdr(sc->code);
                    sc->value = car(sc->code);
                    if (!is_pair(sc->value))
                    {
                        if (is_symbol(sc->value))
                            sc->value = lookup_checked(sc, sc->value);
                        sc->code = cdr(sc->code);
                        return(false);
                    }
                    push_stack_no_args(sc, OP_WITH_LET1, cdr(sc->code));
                    sc->code = sc->value;   /* eval env arg */
                    return(true);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x15814d
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x158132
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0xde990
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x158104
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x15811b
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0xdead0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x1581b6
jmp 0x15814f
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1f2, %ecx            # imm = 0x1F2
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: check_with_baffle
static s7_pointer check_with_baffle(s7_scheme *sc)
    {
        if (!s7_is_proper_list(sc, sc->code))
            eval_error(sc, "with-baffle: unexpected dot? ~A", 31, sc->code);
        if (!is_null(cdr(sc->code)))
            pair_set_syntax_op(sc->code, OP_WITH_BAFFLE_UNCHECKED);
        return(sc->code);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x31a40
testb $0x1, %al
jne 0x158256
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x1918(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
leaq 0x9922e(%rip), %rsi     # 0x1f144d
movl $0x1f, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
callq 0xb830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq %rax, 0x20(%rsp)
jmp 0x1582b3
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x1582a6
jmp 0x158272
movq 0x18(%rsp), %rax
movq (%rax), %rax
movw $0x1f6, 0x4(%rax)       # imm = 0x1F6
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
andq $-0x10000, %rcx         # imm = 0xFFFF0000
orq $0x201, %rcx            # imm = 0x201
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
jmp 0x1582a6
movq 0x18(%rsp), %rax
movq (%rax), %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: op_with_baffle_unchecked
static bool op_with_baffle_unchecked(s7_scheme *sc)
    {
        set_current_code(sc, sc->code);
        sc->code = cdr(sc->code);
        if (is_null(sc->code))
        {
            sc->value = sc->nil;
            return(true);
        }
        new_frame(sc, sc->envir, sc->envir);
        make_slot_1(sc, sc->envir, sc->baffle_symbol, make_baffle(sc));
        return(false);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x158323
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x20(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x158416
jmp 0x158325
jmp 0x158327
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x15834b
movq 0x28(%rsp), %rdi
callq 0xc670
movq 0x28(%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 $0x20001c, (%rax)       # imm = 0x20001C
movq 0x28(%rsp), %rax
movq 0x250(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x250(%rax)
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x17d8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x198080
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
callq 0xbec0
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_read_done
static void op_read_done(s7_scheme *sc)
                {
                    pop_input_port(sc);
                    if (sc->tok == TOKEN_EOF)
                        sc->value = eof_object;
                    sc->current_file = NULL; /* this is for error handling */
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x274d0
movq (%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x158597
movq 0xbdd01(%rip), %rcx     # 0x216290
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x6a8(%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_load_return_if_eof
static bool op_load_return_if_eof(s7_scheme *sc)
                {
                    /* loop here until eof (via push stack below) */
                    /* load("file"); from C (g_load) -- assume caller will clean up
                     *   read and evaluate exprs until EOF that matches (stack reflects nesting)
                     */
                    if (sc->tok != TOKEN_EOF)
                    {
                        push_stack_op_let(sc, OP_LOAD_RETURN_IF_EOF);
                        push_stack_op_let(sc, OP_READ_INTERNAL);
                        sc->code = sc->value;
                        return(true);             /* we read an expression, now evaluate it, and return to read the next */
                    }
                    sc->current_file = NULL;
                    return(false);
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x0, 0x30(%rax)
je 0x158652
jmp 0x1585c6
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x1dd, %ecx            # imm = 0x1DD
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
jmp 0x158601
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl $0x190, %ecx            # imm = 0x190
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rsp)
jmp 0x158667
movq -0x10(%rsp), %rax
movq $0x0, 0x6a8(%rax)
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: pop_read_list
static bool pop_read_list(s7_scheme *sc)
                {
                    /* push-stack OP_READ_LIST is always no_code and op is always OP_READ_LIST (and not used), sc->envir is apparently not needed here */
                    sc->stack_end -= 4;
                    sc->args = sc->stack_end[2];
                    if (is_null(sc->args))
                    {
                        sc->args = cons(sc, sc->value, sc->args);
                        set_file_and_line_number(sc, sc->args);
#if WITH_PROFILE
                        profile_set_location(x, remember_location(port_line_number(sc->input_port), port_file_number(sc->input_port)));
#endif
                        return(true);
                    }
                    return(false);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x50(%rax)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x1588e8
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x15886b
movq 0x28(%rsp), %rdi
callq 0xc670
movq 0x28(%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 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xdfe30
movb $0x1, 0x37(%rsp)
jmp 0x1588ed
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: read_atom
static int32_t read_atom(s7_scheme *sc, s7_pointer pt)
                {
                    push_stack_no_let_no_code(sc, OP_READ_LIST, sc->args);
                    check_stack_size(sc);
                    sc->value = port_read_name(pt)(sc, pt);
                    sc->args = cons(sc, sc->value, sc->nil);
                    set_file_and_line_number(sc, sc->args);
#if WITH_PROFILE
                    profile_set_location(x, remember_location(port_line_number(pt), port_file_number(pt)));
#endif
                    return(port_read_white_space(pt)(sc, pt));
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
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 $0x1d1, %ecx            # imm = 0x1D1
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x50(%rax)
jmp 0x158949
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jb 0x158967
movq 0x30(%rsp), %rdi
callq 0x10fdc0
jmp 0x158969
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq *%rax
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1589d5
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, 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 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xdfe30
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq *%rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: read_double_quote
static void read_double_quote(s7_scheme *sc)
                {
                    sc->value = read_string_constant(sc, sc->input_port);
                    if (sc->value == sc->F)                                /* can happen if input code ends in the middle of a string */
                        string_read_error(sc, "end of input encountered while in a string");
                    if (sc->value == sc->T)
                        read_error(sc, "unknown backslash usage -- perhaps you meant two backslashes?");
                    if (sc->safety > IMMUTABLE_VECTOR_SAFETY) set_immutable(sc->value);
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x170(%rax), %rsi
callq 0x198570
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x159919
movq (%rsp), %rdi
leaq 0x97cca(%rip), %rsi     # 0x1f15de
callq 0x198da0
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rsp), %rcx
cmpq 0x118(%rcx), %rax
jne 0x15993e
movq (%rsp), %rdi
leaq 0x97cd0(%rip), %rsi     # 0x1f1609
callq 0xdfe00
movq (%rsp), %rax
cmpq $0x1, 0x6a0(%rax)
jle 0x159961
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: read_sharp_const
static inline bool read_sharp_const(s7_scheme *sc)
                {
                    sc->value = port_read_sharp(sc->input_port)(sc, sc->input_port);
                    if (sc->value == sc->no_value)
                    {
                        /* (set! *#readers* (cons (cons #\; (lambda (s) (read) (values))) *#readers*))
                         * (+ 1 #;(* 2 3) 4)
                         * so we need to get the next token, act on it without any assumptions about read list
                         */
                        sc->tok = token(sc);
                        return(true);
                    }
                    return(false);
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq 0x30(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x170(%rcx), %rsi
callq *%rax
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x138(%rcx), %rax
jne 0x159d72
movq 0x8(%rsp), %rdi
callq 0xc9560
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x30(%rax)
movb $0x1, 0x17(%rsp)
jmp 0x159d77
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_read_quote
static bool op_read_quote(s7_scheme *sc)
                {
                    /* can't check for sc->value = sc->nil here because we want ''() to be different from '() */
                    if ((sc->safety > IMMUTABLE_VECTOR_SAFETY) &&
                            ((is_pair(sc->value)) || (is_any_vector(sc->value)) || (is_string(sc->value))))
                        set_immutable(sc->value);
                    sc->value = list_2(sc, sc->quote_symbol, sc->value);
                    return(main_stack_op(sc) != OP_READ_LIST);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x1, 0x6a0(%rax)
jle 0x15a06b
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x15a055
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xc0712(%rip), %rax     # 0x21a750
testb $0x1, (%rax,%rcx)
jne 0x15a055
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
jne 0x15a06b
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x17b0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x15a0c8
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, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdx
callq 0xd9f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rax), %rax
cmpq $0x1d1, %rax            # imm = 0x1D1
setne %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_read_unquote
static bool op_read_unquote(s7_scheme *sc)
                {
                    /* here if sc->value is a constant, the unquote is pointless (should we complain?) */
                    if ((is_pair(sc->value)) ||
                            (is_symbol(sc->value)))
                        sc->value = list_2(sc, sc->unquote_symbol, sc->value);
                    return(main_stack_op(sc) != OP_READ_LIST);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x15a1cf
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x15a2a0
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x17b8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x15a22c
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, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdx
callq 0xd9f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rax), %rax
cmpq $0x1d1, %rax            # imm = 0x1D1
setne %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_read_vector
static bool op_read_vector(s7_scheme *sc)
                {
                    if (is_dotted_pair(sc->value))            /* #(1 . 2) */
                        read_error(sc, "vector constant data is not a proper list");
                    sc->v = sc->value;
                    if (sc->args == small_int(1))             /* sc->args was sc->w earlier from read_sharp */
                        sc->value = g_vector(sc, sc->value);
                    else sc->value = g_multivector(sc, integer(sc->args), sc->value);
                    /* here and below all of the sc->value list can be freed, but my tests showed no speed up even in large cases */
                    free_vlist(sc, sc->v);
                    if (sc->safety > IMMUTABLE_VECTOR_SAFETY) set_immutable(sc->value);
                    return(main_stack_op(sc) != OP_READ_LIST);
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x15a4ac
movq (%rsp), %rdi
leaq 0x97343(%rip), %rsi     # 0x1f17ea
callq 0xdfe00
movq (%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0xbbfba(%rip), %rax     # 0x216488
jne 0x15a4ee
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x9a230
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x15a516
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rax
movq 0x20(%rax), %rdx
callq 0x19a120
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x4d0(%rax), %rsi
callq 0x19a6a0
movq (%rsp), %rax
cmpq $0x1, 0x6a0(%rax)
jle 0x15a54d
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rax), %rax
cmpq $0x1d1, %rax            # imm = 0x1D1
setne %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_read_int_vector
static bool op_read_int_vector(s7_scheme *sc)
                {
                    if (is_dotted_pair(sc->value))
                        read_error(sc, "int-vector constant data is not a proper list");
                    sc->v = sc->value;
                    if (sc->args == small_int(1))             /* sc->args was sc->w earlier from read_sharp */
                        sc->value = g_int_vector(sc, sc->value);
                    else sc->value = g_int_multivector(sc, integer(sc->args), sc->value);
                    free_vlist(sc, sc->v);
                    if (sc->safety > IMMUTABLE_VECTOR_SAFETY) set_immutable(sc->value);
                    return(main_stack_op(sc) != OP_READ_LIST);
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x15a59c
movq (%rsp), %rdi
leaq 0x971e0(%rip), %rsi     # 0x1f1777
callq 0xdfe00
movq (%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0xbbeca(%rip), %rax     # 0x216488
jne 0x15a5de
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x9b780
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x15a606
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rax
movq 0x20(%rax), %rdx
callq 0x19a900
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x4d0(%rax), %rsi
callq 0x19a6a0
movq (%rsp), %rax
cmpq $0x1, 0x6a0(%rax)
jle 0x15a63d
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rax), %rax
cmpq $0x1d1, %rax            # imm = 0x1D1
setne %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_read_float_vector
static bool op_read_float_vector(s7_scheme *sc)
                {
                    if (is_dotted_pair(sc->value))
                        read_error(sc, "float-vector constant data is not a proper list");
                    sc->v = sc->value;
                    if (sc->args == small_int(1))             /* sc->args was sc->w earlier from read_sharp */
                        sc->value = g_float_vector(sc, sc->value);
                    else sc->value = g_float_multivector(sc, integer(sc->args), sc->value);
                    free_vlist(sc, sc->v);
                    if (sc->safety > IMMUTABLE_VECTOR_SAFETY) set_immutable(sc->value);
                    return(main_stack_op(sc) != OP_READ_LIST);
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x15a68c
movq (%rsp), %rdi
leaq 0x97126(%rip), %rsi     # 0x1f17ad
callq 0xdfe00
movq (%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0xbbdda(%rip), %rax     # 0x216488
jne 0x15a6ce
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x9ae10
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x15a6f6
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rax
movq 0x20(%rax), %rdx
callq 0x19aaa0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x4d0(%rax), %rsi
callq 0x19a6a0
movq (%rsp), %rax
cmpq $0x1, 0x6a0(%rax)
jle 0x15a72d
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rax), %rax
cmpq $0x1d1, %rax            # imm = 0x1D1
setne %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: op_read_byte_vector
static bool op_read_byte_vector(s7_scheme *sc)
                {
                    if (is_dotted_pair(sc->value))
                        read_error(sc, "byte-vector constant data is not a proper list");
                    sc->v = sc->value;
                    if (sc->args == small_int(1))             /* sc->args was sc->w earlier from read_sharp */
                        sc->value = g_byte_vector(sc, sc->value);
                    else sc->value = g_byte_multivector(sc, integer(sc->args), sc->value);
                    free_vlist(sc, sc->v);
                    if (sc->safety > IMMUTABLE_VECTOR_SAFETY) set_immutable(sc->value);
                    return(main_stack_op(sc) != OP_READ_LIST);
                }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x15a77c
movq (%rsp), %rdi
leaq 0x9706e(%rip), %rsi     # 0x1f17e5
callq 0xdfe00
movq (%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0xbbcea(%rip), %rax     # 0x216488
jne 0x15a7be
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x9bee0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x15a7e6
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rax
movq 0x20(%rax), %rdx
callq 0x19ac40
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x4d0(%rax), %rsi
callq 0x19a6a0
movq (%rsp), %rax
cmpq $0x1, 0x6a0(%rax)
jle 0x15a81d
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
orq $0x1000000, %rcx        # imm = 0x1000000
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rax), %rax
cmpq $0x1d1, %rax            # imm = 0x1D1
setne %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: clear_all_optimizations
static void clear_all_optimizations(s7_scheme *sc, s7_pointer p)
    {
        /* I believe that we would not have been optimized to begin with if the tree were circular,
         *   and this tree is supposed to be a function call + args -- a circular list here is a bug.
         */
        if (is_pair(p))
        {
            if ((is_optimized(p)) &&
                    ((optimize_op(p) & 1) == 0)) /* protect possibly shared code?  Elsewhere we assume these aren't changed */
            {
                clear_optimized(p);     /* includes T_SYNTACTIC */
                clear_optimize_op(p);
            }
            clear_all_optimizations(sc, cdr(p));
            clear_all_optimizations(sc, car(p));
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x15a8bd
movq 0x8(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x801, %eax            # imm = 0x801
jne 0x15a897
movq 0x8(%rsp), %rax
movzwl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x15a897
movq 0x8(%rsp), %rax
movzwl (%rax), %ecx
andl $0xfffff5fb, %ecx       # imm = 0xFFFFF5FB
movw %cx, (%rax)
movq 0x8(%rsp), %rax
movw $0x0, 0x4(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x15a840
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x15a840
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_cell_optimize
static s7_function s7_cell_optimize(s7_scheme *sc, s7_pointer expr, bool nr)
                {
#if WITH_GMP
                    return(NULL);
#endif
                    if (setjmp(sc->opt_exit) == 0)
                    {
                        sc->pc = 0;
                        reset_opts(sc);
                        if (cell_optimize(sc, expr))
                            return((nr) ? opt_cell_any_nr : opt_wrap_cell);
                    }
                    return(NULL);
                }

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x18(%rsp), %rdi
addq $0x2190, %rdi           # imm = 0x2190
callq 0x9350
cmpl $0x0, %eax
jne 0x15c7d2
movq 0x18(%rsp), %rax
movl $0x0, 0x2258(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe9db0
testb $0x1, %al
jne 0x15c7b0
jmp 0x15c7d0
movb 0xf(%rsp), %dl
leaq -0x44a8b(%rip), %rax    # 0x117d30
leaq -0x44ad2(%rip), %rcx    # 0x117cf0
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x15c7db
jmp 0x15c7d2
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: tree_has_setters
static bool tree_has_setters(s7_scheme *sc, s7_pointer tree)
                {
                    clear_symbol_list(sc);
                    add_symbol_to_list(sc, sc->set_symbol);
                    add_symbol_to_list(sc, sc->vector_set_symbol);
                    add_symbol_to_list(sc, sc->list_set_symbol);
                    add_symbol_to_list(sc, sc->let_set_symbol);
                    add_symbol_to_list(sc, sc->hash_table_set_symbol);
                    add_symbol_to_list(sc, sc->set_car_symbol);
                    add_symbol_to_list(sc, sc->set_cdr_symbol);
                    return(tree_set_memq(sc, tree));                /* TODO: if val is constant don't treat as a hit */
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xdd1b0
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18d8(%rax), %rsi
callq 0xde160
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x1668(%rax), %rsi
callq 0xde160
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x1260(%rax), %rsi
callq 0xde160
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x1240(%rax), %rsi
callq 0xde160
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0xf70(%rax), %rsi
callq 0xde160
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x14a8(%rax), %rsi
callq 0xde160
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x14b0(%rax), %rsi
callq 0xde160
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x15c8c0
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: tree_set_memq
static bool tree_set_memq(s7_scheme *sc, s7_pointer tree)
    {
        if (is_symbol(tree))
            return(symbol_is_in_list(sc, tree));
        if ((!is_pair(tree)) ||
                (car(tree) == sc->quote_symbol))
            return(false);
        return(pair_set_memq(sc, tree));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x15c924
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpl 0xa88(%rdx), %ecx
movb %al, 0xf(%rsp)
jne 0x15c918
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0xa8c(%rcx), %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x15c964
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x15c948
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
jne 0x15c94f
movb $0x0, 0x27(%rsp)
jmp 0x15c964
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15c970
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: pair_set_memq
static inline bool pair_set_memq(s7_scheme *sc, s7_pointer tree)
    {
        while (true)
        {
            s7_pointer p;
            p = car(tree);
            if (is_symbol(p))
            {
                if (symbol_is_in_list(sc, p))
                    return(true);
            }
            if ((is_unquoted_pair(p)) &&
                    (pair_set_memq(sc, p)))
                return(true);
            tree = cdr(tree);
            if (!is_pair(tree)) break;
        }
        return((is_symbol(tree)) && (symbol_is_in_list(sc, tree)));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x15c9d7
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0xa88(%rcx), %eax
jne 0x15c9d5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0xa8c(%rcx), %eax
jne 0x15c9d5
movb $0x1, 0x27(%rsp)
jmp 0x15ca9e
jmp 0x15c9d7
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x15ca1a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
je 0x15ca1a
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x15c970
testb $0x1, %al
jne 0x15ca10
jmp 0x15ca1a
movb $0x1, 0x27(%rsp)
jmp 0x15ca9e
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x15ca37
jmp 0x15ca3c
jmp 0x15c97e
movq 0x10(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, 0x7(%rsp)
jne 0x15ca94
movq 0x10(%rsp), %rax
movl 0x2c(%rax), %ecx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpl 0xa88(%rdx), %ecx
movb %al, 0x6(%rsp)
jne 0x15ca8c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movl 0xc(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0xa8c(%rcx), %eax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: symbol_is_in_arg_list
static bool symbol_is_in_arg_list(s7_pointer sym, s7_pointer lst)
    {
        s7_pointer x;
        for (x = lst; is_pair(x); x = cdr(x))
            if ((sym == car(x)) ||
                    ((is_pair(car(x))) &&
                     (sym == caar(x))))
                return(true);
        return(sym == x);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x15cbaf
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0x15cb96
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x15cb9d
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0x15cb9d
movb $0x1, -0x1(%rsp)
jmp 0x15cbc2
jmp 0x15cb9f
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x15cb54
movq -0x10(%rsp), %rax
cmpq -0x20(%rsp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_goto
static inline s7_pointer make_goto(s7_scheme *sc)
    {
        s7_pointer x;
        new_cell(sc, x, T_GOTO);
        call_exit_goto_loc(x) = s7_stack_top(sc);
        call_exit_op_loc(x) = (int32_t)(sc->op_stack_now - sc->op_stack);
        call_exit_active(x) = true;
        return(x);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x15cbfd
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%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 $0x26, (%rax)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
subq %rax, %rcx
sarq $0x3, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x60(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movslq %eax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: set_c_function_star_defaults
static s7_pointer set_c_function_star_defaults(s7_scheme *sc, int32_t num)
                {
                    s7_pointer call_args, func, par;
                    int32_t n_args;

                    func = sc->code;
                    n_args = c_function_all_args(func);

                    if (is_safe_procedure(func))
                        call_args = c_function_call_args(func);
                    else call_args = protected_make_list(sc, n_args, sc->F);

                    par = call_args;
                    if (num == 1)
                    {
                        set_car(par, car(sc->args));
                        par = cdr(par);
                    }
                    fill_star_defaults(sc, func, num, n_args, par);
                    return(call_args);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x200000, %rax         # imm = 0x200000
cmpq $0x0, %rax
je 0x15ccdf
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x60(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x15ccff
movq 0x30(%rsp), %rdi
movslq 0xc(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x120(%rax), %rdx
callq 0xde940
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x2c(%rsp)
jne 0x15cd34
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x2c(%rsp), %edx
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %r8
callq 0xdfc00
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: closure_arity_to_int
static int32_t closure_arity_to_int(s7_scheme *sc, s7_pointer x)
                {
                    /* not lambda* here */
                    if (closure_arity_unknown(x))
                    {
                        int32_t i;
                        s7_pointer b;
                        for (i = 0, b = closure_args(x); is_pair(b); i++, b = cdr(b)) {};
                        if (is_null(b))
                            closure_set_arity(x, i);
                        else
                        {
                            if (i == 0)
                                return(-1);
                            closure_set_arity(x, -i);
                        }
                    }
                    return(closure_arity(x));
                }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpl $0x40000000, 0x28(%rax) # imm = 0x40000000
jne 0x15cdfe
movl $0x0, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x15cdbc
jmp 0x15cda1
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x15cd92
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x15cddd
movl -0x1c(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, 0x28(%rax)
jmp 0x15cdfc
cmpl $0x0, -0x1c(%rsp)
jne 0x15cdee
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x15ce0a
xorl %ecx, %ecx
subl -0x1c(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, 0x28(%rax)
jmp 0x15cdfe
movq -0x18(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: unknown_unknown
static goto_t unknown_unknown(s7_scheme *sc)
                {
                    if ((is_symbol(car(sc->code))) &&
                            (!is_slot(symbol_to_slot(sc, car(sc->code)))))
                        eval_error_no_return(sc, sc->unbound_variable_symbol, "~A: unbound variable", 20, car(sc->code));
                    return(fall_through);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x15ceb5
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
callq 0xfc80
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x15ceb5
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x1958(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x9365d(%rip), %rsi     # 0x1f04dd
movl $0x14, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
callq 0xb830
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movl $0x2, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_immutable_and_stable
static bool is_immutable_and_stable(s7_scheme *sc, s7_pointer func)
                {
                    s7_pointer p;
                    if (symbol_ctr(func) != 1) /* protect against (define-constant (p) (define-constant (p) ...)) */
                        return(false);
                    if ((is_global(func)) && (is_immutable_slot(global_slot(func))))
                        return(true);
                    for (p = sc->envir; is_let(p); p = outlet(p))
                        if ((is_funclet(p)) && (funclet_function(p) != func))
                            return(false);
                    p = symbol_to_slot(sc, func);
                    return(is_immutable_slot(p));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x1, 0x28(%rax)
je 0x15cee3
movb $0x0, 0x27(%rsp)
jmp 0x15cfa0
movq 0x10(%rsp), %rax
movq (%rax), %rax
andq $0x10000, %rax          # imm = 0x10000
cmpq $0x0, %rax
je 0x15cf19
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
je 0x15cf19
movb $0x1, 0x27(%rsp)
jmp 0x15cfa0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0x15cf71
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x15cf5f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
cmpq 0x10(%rsp), %rax
je 0x15cf5f
movb $0x0, 0x27(%rsp)
jmp 0x15cfa0
jmp 0x15cf61
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x15cf27
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xfc80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
andq $0x1000000, %rax        # imm = 0x1000000
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)