LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table_set
static s7_pointer g_hash_table_set(s7_scheme *sc, s7_pointer args)
                {
#define H_hash_table_set "(hash-table-set! table key value) sets the value associated with key in the hash table to value"
#define Q_hash_table_set s7_make_signature(sc, 4, sc->T, sc->is_hash_table_symbol, sc->T, sc->T)

                    s7_pointer table;
                    table = car(args);
                    if (!is_mutable_hash_table(table))
                        return(mutable_method_or_bust(sc, table, sc->hash_table_set_symbol, args, T_HASH_TABLE, 1));
                    return(s7_hash_table_set(sc, table, cadr(args), caddr(args)));
                }

// Assembly:
movq %rsi, %rcx
movq 0x8(%rsi), %rsi
movl $0x10000ff, %eax        # imm = 0x10000FF
andl (%rsi), %eax
cmpl $0x1b, %eax
jne 0x82205
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
jmp 0x38db7
movq 0xf70(%rdi), %rdx
movl $0x1b, %r8d
jmp 0xeff2b
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_hash_table_entries
static s7_pointer g_hash_table_entries(s7_scheme *sc, s7_pointer args)
                {
#define H_hash_table_entries "(hash-table-entries obj) returns the number of entries in the hash-table obj"
#define Q_hash_table_entries s7_make_signature(sc, 2, sc->is_integer_symbol, sc->is_hash_table_symbol)

                    if (!is_hash_table(car(args)))
                        return(method_or_bust_one_arg(sc, car(args), sc->hash_table_entries_symbol, args, T_HASH_TABLE));
                    return(make_integer(sc, hash_table_entries(car(args))));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpb $0x1b, (%rsi)
jne 0x82248
movq 0x28(%rsi), %rax
movq 0x18(%rax), %r14
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x82264
leaq 0xcc70e(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x8229d
movq 0xf60(%rbx), %rdx
movq %rbx, %rdi
movl $0x1b, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b739
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x8227c
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_eval
static s7_pointer g_eval(s7_scheme *sc, s7_pointer args)
                {
#define H_eval "(eval code (env (curlet))) evaluates code in the environment env. 'env' \
                    defaults to the curlet; to evaluate something in the top-level environment instead, \
                    pass (rootlet):\n\
                    \n\
                    (define x 32) \n\
                    (let ((x 3))\n\
                     (eval 'x (rootlet)))\n\
                    \n\
                    returns 32"
#define Q_eval s7_make_signature(sc, 3, sc->values_symbol, sc->T, sc->is_let_symbol)

                    if (is_not_null(cdr(args)))
                    {
                        s7_pointer e;
                        e = cadr(args);
                        if (!is_let(e))
                            return(wrong_type_argument_with_type(sc, sc->eval_symbol, 2, e, a_let_string));
                        if (e == sc->rootlet)
                            sc->envir = sc->nil;
                        else sc->envir = e;
                    }
                    sc->code = car(args);

                    if ((sc->safety > NO_SAFETY) &&
                            (is_pair(sc->code)))
                    {
                        check_heap_size(sc, 8192);
                        sc->code = copy_body(sc, sc->code);
                    }
                    else
                    {
                        if (is_optimized(sc->code))
                            clear_all_optimizations(sc, sc->code);
                    }

                    if (s7_stack_top(sc) < 12)
                        push_stack_op(sc, OP_BARRIER);
                    push_stack(sc, OP_EVAL, sc->args, sc->code);

                    return(sc->nil);
                }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
movq 0x110(%rdi), %rax
cmpq %rax, %rcx
je 0x830d6
movq 0x8(%rcx), %rcx
movb (%rcx), %bpl
cmpb $0x1c, %bpl
jne 0x8309e
cmpq 0x150(%rbx), %rcx
je 0x830c8
movq %rcx, 0x8(%rbx)
jmp 0x830cc
movq 0xeb8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xcb8b0(%rip), %rdx     # 0x14e960
movq 0x140(%rbx), %r8
movq 0xcf89a(%rip), %r9      # 0x152958
movq %rbx, %rdi
callq 0xb31d
jmp 0x830cc
movq %rax, 0x8(%rbx)
cmpb $0x1c, %bpl
jne 0x8316d
movq 0x8(%r14), %rdi
movq %rdi, (%rbx)
cmpq $0x0, 0x6a0(%rbx)
jle 0x83109
cmpb $0x1, (%rdi)
jne 0x83109
movl $0x2000, %esi           # imm = 0x2000
movq %rbx, %rdi
callq 0x3e1dd
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0xa0bf9
movq %rax, (%rbx)
jmp 0x83115
cmpw $0x801, (%rdi)          # imm = 0x801
jne 0x83115
callq 0xd4d0e
movq 0x50(%rbx), %rax
movq %rax, %rcx
subq 0x48(%rbx), %rcx
cmpq $0x5f, %rcx
jg 0x83133
movq $0x203, 0x18(%rax)      # imm = 0x203
addq $0x20, 0x50(%rbx)
movq (%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x191, 0x18(%rax)      # imm = 0x191
addq $0x20, 0x50(%rbx)
movq 0x110(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_eval_string
static s7_pointer g_eval_string(s7_scheme *sc, s7_pointer args)
    {
#define H_eval_string "(eval-string str (env (curlet))) returns the result of evaluating the string str as Scheme code"
#define Q_eval_string s7_make_signature(sc, 3, sc->values_symbol, sc->is_string_symbol, sc->is_let_symbol)
        s7_pointer port, str;

        str = car(args);
        if (!is_string(str))
            return(method_or_bust(sc, str, sc->eval_string_symbol, args, T_STRING, 1));

        if (is_not_null(cdr(args)))
        {
            s7_pointer e;
            e = cadr(args);
            if (!is_let(e))
                return(wrong_type_argument_with_type(sc, sc->eval_string_symbol, 2, e, a_let_string));
            if (e == sc->rootlet)
                sc->envir = sc->nil;
            else sc->envir = e;
        }

        port = open_and_protect_input_string(sc, str);
        push_input_port(sc, port);

        sc->temp3 = sc->args;
        push_stack(sc, OP_EVAL_STRING, args, sc->code);
        push_stack_op_let(sc, OP_READ_INTERNAL);

        return(sc->F);  /* I think this means that sc->value defaults to #f in op_eval_string below, so (eval-string "") mimics (eval) -> #f */
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
cmpb $0x13, (%r15)
jne 0x831b5
movq 0x10(%r14), %rcx
movq 0x110(%rbx), %rax
cmpq %rax, %rcx
je 0x83218
movq 0x8(%rcx), %rcx
movb (%rcx), %bpl
cmpb $0x1c, %bpl
jne 0x831e0
cmpq 0x150(%rbx), %rcx
je 0x8320a
movq %rcx, 0x8(%rbx)
jmp 0x8320e
movq 0xeb0(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
movl $0x13, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf1ae
movq 0xeb0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0xcb76e(%rip), %rdx     # 0x14e960
movq 0x140(%rbx), %r8
movq 0xcf758(%rip), %r9      # 0x152958
movq %rbx, %rdi
callq 0xb31d
jmp 0x8320e
movq %rax, 0x8(%rbx)
cmpb $0x1c, %bpl
jne 0x832dc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10305b
movq %rax, %r15
movl 0x180(%rbx), %esi
cmpl %esi, 0x184(%rbx)
jb 0x83253
addl %esi, %esi
movl %esi, 0x180(%rbx)
movq 0x178(%rbx), %rdi
shlq $0x3, %rsi
callq 0x9510
movq %rax, 0x178(%rbx)
movq 0x170(%rbx), %rax
movq 0x178(%rbx), %rcx
movl 0x184(%rbx), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x184(%rbx)
movq %rax, (%rcx,%rdx,8)
movq %r15, 0x170(%rbx)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x508(%rbx)
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x50(%rbx), %rax
movq %r14, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x20f, 0x18(%rax)      # imm = 0x20F
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
leaq 0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x28(%rcx)
movq 0x50(%rbx), %rax
movq $0x190, 0x18(%rax)      # imm = 0x190
addq $0x20, 0x50(%rbx)
movq 0x120(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_error
static s7_pointer g_error(s7_scheme *sc, s7_pointer args)
                {
#define H_error "(error type ...) signals an error.  The 'type' can be used with catch to trap \
                    particular errors.  If the error is not caught, s7 treats the second argument as a format control string, \
                    and applies it to the rest of the arguments."
#define Q_error s7_make_circular_signature(sc, 1, 2, sc->values_symbol, sc->T)

                    if (is_not_null(args))
                    {
                        if (is_string(car(args)))                     /* CL-style error? -- use tag = 'no-catch */
                        {
                            s7_error(sc, sc->no_catch_symbol, args);  /* this can have trailing args (implicit format) */
                            return(sc->unspecified);
                        }
                        return(s7_error(sc, car(args), cdr(args)));
                    }
                    return(s7_error(sc, sc->nil, sc->nil));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x110(%rdi), %rbx
cmpq %rsi, %rbx
je 0x84cc9
movq %rsi, %rdx
movq 0x8(%rsi), %rbx
cmpb $0x13, (%rbx)
jne 0x84cd4
movq 0x1928(%r14), %rsi
movq %r14, %rdi
callq 0x3b366
movq 0x130(%r14), %rbx
jmp 0x84ce3
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
jmp 0x84cde
movq 0x10(%rdx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_apply_values
static s7_pointer g_apply_values(s7_scheme *sc, s7_pointer args)
                {
#define H_apply_values "(apply-values var) applies values to var.  This is an internal function."
#define Q_apply_values s7_make_signature(sc, 2, sc->T, sc->is_list_symbol)
                    s7_pointer x;
                    /* apply-values takes 1 arg: ,@a -> (apply-values a) */
                    if (is_null(args))
                        return(sc->no_value);

                    x = car(args);
                    if (is_null(x))
                        return(sc->no_value);

                    if (!s7_is_proper_list(sc, x))
                        return(apply_list_error(sc, args));

                    return(g_values(sc, x));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x110(%rdi), %rax
cmpq %rsi, %rax
je 0x84f08
movq %rsi, %r14
movq 0x8(%rsi), %r15
cmpq %rax, %r15
je 0x84f08
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c2fb
movq %rbx, %rdi
testb %al, %al
je 0x84f15
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x48622
movq 0x138(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd568c
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_help
static s7_pointer g_help(s7_scheme *sc, s7_pointer args)
                {
#define H_help "(help obj) returns obj's documentation"
#define Q_help s7_make_signature(sc, 2, s7_make_signature(sc, 2, sc->is_string_symbol, sc->is_boolean_symbol), sc->T)
                    const char *doc;

                    check_method(sc, car(args), sc->help_symbol, args);
                    doc = s7_help(sc, car(args));
                    if (!doc)
                        return(sc->F);
                    return(s7_make_string(sc, doc));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movb $0x1, %bpl
testb $0x40, 0x3(%rsi)
je 0x854bd
cmpb $0x1, 0x24c(%rbx)
jne 0x854bd
movq %rbx, %rdi
callq 0x9a55
movq 0xf80(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x99ef
cmpq 0x128(%rbx), %rax
je 0x854bd
cmpb $0x1, (%r14)
jne 0x85502
movq %rax, 0x10(%rsp)
movq %r14, 0x4c8(%rbx)
movq 0x8(%r14), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r15
cmpq 0x98(%rbx), %rax
ja 0x85401
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r13, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0x4e8(%rbx)
movq 0x10(%r14), %r13
cmpb $0x1, (%r13)
jne 0x8549c
movq 0x8(%rsp), %rbp
movq 0x8(%r13), %r15
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r12
cmpq 0x98(%rbx), %rax
ja 0x85465
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x10(%rbp)
movq 0x10(%r13), %r13
cmpb $0x1, (%r13)
movq %rax, %rbp
je 0x85442
movq 0x110(%rbx), %rax
movq %rax, 0x4e8(%rbx)
movq %rax, 0x4c8(%rbx)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
jmp 0x85509
testb %bpl, %bpl
je 0x854f3
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x40f4e
testq %rax, %rax
je 0x854ec
movq %rbx, %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf735
movq 0x120(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x110(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbd41
xorl %ebp, %ebp
jmp 0x854bd
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_dilambda
static s7_pointer g_dilambda(s7_scheme *sc, s7_pointer args)
                {
#define H_dilambda "(dilambda getter setter) sets getter's setter to be setter."
#define Q_dilambda s7_make_signature(sc, 3, sc->is_procedure_symbol, sc->is_procedure_symbol, sc->is_procedure_symbol)
                    s7_pointer getter, setter;

                    getter = car(args);
                    if (!is_any_procedure(getter))
                        return(wrong_type_argument_with_type(sc, sc->dilambda_symbol, 1, getter, wrap_string(sc, "a procedure or a macro", 22)));

                    setter = cadr(args);
                    if (!is_any_procedure(setter))
                        return(wrong_type_argument_with_type(sc, sc->dilambda_symbol, 2, setter, wrap_string(sc, "a procedure or a macro", 22)));

                    s7_set_setter(sc, getter, setter);
                    return(getter);
                }

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rbx
cmpb $0x27, (%rbx)
jbe 0x85ac9
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rcx
cmpb $0x27, (%rcx)
jbe 0x85b18
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x42554
movq %rbx, %rax
popq %rbx
retq
movq 0xe78(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xc8e7d(%rip), %rdx     # 0x14e958
movq 0x140(%rdi), %r8
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %rcx
movq (%rax,%rcx,8), %r9
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x9f2b2(%rip), %rax     # 0x124db9
movq %rax, 0x10(%r9)
movq $0x16, 0x8(%r9)
movq %rbx, %rcx
jmp 0x85b63
movq 0xe78(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0xc8e36(%rip), %rdx     # 0x14e960
movq 0x140(%rdi), %r8
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r10
movq (%rax,%r10,8), %r9
leal 0x1(%r10), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0x9f262(%rip), %rax     # 0x124db9
movq %rax, 0x10(%r9)
movq $0x16, 0x8(%r9)
popq %rbx
jmp 0xb31d
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_is_aritable
static s7_pointer g_is_aritable(s7_scheme *sc, s7_pointer args)
                {
#define H_is_aritable "(aritable? obj num-args) returns #t if 'obj can be applied to 'num-args arguments."
#define Q_is_aritable s7_make_signature(sc, 3, sc->is_boolean_symbol, sc->T, sc->is_integer_symbol)

                    s7_pointer n;
                    s7_int num;

                    n = cadr(args);
                    if (!s7_is_integer(n)) /* remember gmp case! */
                        return(method_or_bust(sc, n, sc->is_aritable_symbol, args, T_INTEGER, 2));

                    num = s7_integer(n);
                    if (num < 0)
                        return(out_of_range(sc, sc->is_aritable_symbol, small_int(2), n, its_negative_string));
                    if (num > MAX_ARITY) num = MAX_ARITY;

                    return(make_boolean(sc, s7_is_aritable(sc, car(args), num)));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
cmpb $0xb, (%rsi)
jne 0x85bb9
movq 0x8(%rsi), %rax
testq %rax, %rax
js 0x85bdb
movl $0x20000000, %edx       # imm = 0x20000000
cmpq %rdx, %rax
cmovlq %rax, %rdx
movq 0x8(%rcx), %rsi
movq %rbx, %rdi
callq 0x41fac
xorb $0x1, %al
movzbl %al, %eax
movq 0x118(%rbx,%rax,8), %r14
jmp 0x85c34
movq 0xfd0(%rbx), %rdx
movq %rbx, %rdi
movl $0xb, %r8d
movl $0x2, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf1ae
movq 0xfd0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc8d73(%rip), %rcx     # 0x14e960
movq 0xcce54(%rip), %rdx     # 0x152a48
movq 0x1ee8(%rbx), %rdi
movq 0x10(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x10(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rbx), %r14
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b366
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_optimize
static s7_pointer g_optimize(s7_scheme *sc, s7_pointer args)
                {
                    s7_function f;
                    s7_pointer code;
                    code = car(args);
                    f = s7_optimize(sc, code);
                    if (f)
                        return(f(sc, car(code)));
                    return(sc->undefined);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x48508
testq %rax, %rax
je 0x85f53
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0x128(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_c_object_set
static s7_pointer g_c_object_set(s7_scheme *sc, s7_pointer args) /* called in c_object_set_function */
                {
                    s7_pointer obj;
                    obj = car(args);
                    if (!is_c_object(obj))
                        return(simple_wrong_type_argument(sc, make_symbol(sc, "c-object-set!"), obj, T_C_OBJECT));
                    return((*(c_object_set(sc, obj)))(sc, args));
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x14, (%r14)
jne 0x85f92
movq 0x8d8(%rbx), %rax
movq 0x8(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x9e78c(%rip), %rsi     # 0x124725
movl $0xd, %edx
movq %rbx, %rdi
callq 0x9d9f
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xccb48(%rip), %r8      # 0x152b00
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_tree_count
static s7_pointer g_tree_count(s7_scheme *sc, s7_pointer args)
                {
#define H_tree_count "(tree-count obj tree max-count) returns how many times obj is in tree (using eq?), stopping at max-count (if specified)"
#define Q_tree_count s7_make_signature(sc, 4, sc->is_integer_symbol, sc->T, sc->T, sc->is_integer_symbol)
                    s7_pointer obj, tree, count;

                    obj = car(args);
                    tree = cadr(args);
                    if (!is_pair(tree))
                    {
                        if ((is_pair(cddr(args))) &&
                                (!is_t_integer(caddr(args))))
                            return(simple_wrong_type_argument(sc, sc->tree_count_symbol, caddr(args), T_INTEGER));
                        return((obj == tree) ? small_int(1) : small_int(0));
                    }
                    if ((sc->safety > NO_SAFETY) &&
                            (tree_is_cyclic(sc, tree)))
                        s7_error(sc, sc->wrong_type_arg_symbol, wrap_string(sc, "tree-count: tree is cyclic", 26));
                    if (is_null(cddr(args)))
                        return(s7_make_integer(sc, tree_count(sc, obj, tree, 0)));
                    count = caddr(args);
                    if (!s7_is_integer(count))
                        return(simple_wrong_type_argument(sc, sc->tree_count_symbol, count, T_INTEGER));
                    return(s7_make_integer(sc, tree_count_at_least(sc, obj, tree, 0, s7_integer(count))));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r15
cmpb $0x1, (%r15)
jne 0x860d3
movq %rsi, %r12
cmpq $0x0, 0x6a0(%rbx)
jle 0x8609e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b2ff
testb %al, %al
je 0x8609e
movq 0x1940(%rbx), %rsi
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rdx
leal 0x1(%rcx), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0x9ed75(%rip), %rax     # 0x124dff
movq %rax, 0x10(%rdx)
movq $0x1a, 0x8(%rdx)
movq %rbx, %rdi
callq 0x3b366
movq 0x10(%r12), %rax
movq 0x10(%rax), %rax
cmpq 0x110(%rbx), %rax
je 0x86135
movq 0x8(%rax), %rdx
cmpb $0xb, (%rdx)
jne 0x86109
movq 0x8(%rdx), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x109211
jmp 0x86145
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
jne 0x860e5
movq 0x8(%rax), %rdx
cmpb $0xb, (%rdx)
jne 0x86109
cmpq %r15, %r14
leaq 0xc8869(%rip), %rax     # 0x14e958
leaq 0xc885a(%rip), %rcx     # 0x14e950
cmoveq %rax, %rcx
movq (%rcx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x15f8(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xcc996(%rip), %r8      # 0x152ab8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xfac8
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xb0353
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xdff8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_features_set
static s7_pointer g_features_set(s7_scheme *sc, s7_pointer args) /* *features* setter */
    {
        s7_pointer nf;
        nf = cadr(args);
        if (is_null(nf))
            return(sc->nil);
        if (is_pair(nf))
        {
            s7_pointer p;
            if (s7_list_length(sc, nf) <= 0)
                return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *features* to ~S", 26), nf)));
            for (p = nf; is_pair(p); p = cdr(p))
                if (!is_symbol(car(p)))
                    return(simple_wrong_type_argument(sc, sc->features_symbol, car(p), T_SYMBOL));
            return(nf);
        }
        return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *features* to ~S", 26), nf)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
movq 0x110(%rdi), %r15
cmpq %r15, %r14
je 0x86230
movq %rdi, %rbx
cmpb $0x1, (%r14)
jne 0x861cd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c299
testq %rax, %rax
jle 0x861cd
cmpb $0x1, (%r14)
jne 0x861c8
movq %r14, %rax
movq 0x8(%rax), %rdx
cmpb $0xa, (%rdx)
jne 0x86239
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x861b6
movq %r14, %r15
jmp 0x86230
movq 0xea8(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x9ec22(%rip), %rcx     # 0x124e1a
movq %rcx, 0x10(%rax)
movq $0x1a, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b366
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xee0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0xcc85e(%rip), %r8      # 0x152ab0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_load_path_set
static s7_pointer g_load_path_set(s7_scheme *sc, s7_pointer args)
    {
        /* new value must be either () or a proper list of strings */
        if (is_null(cadr(args))) return(cadr(args));
        if (is_pair(cadr(args)))
        {
            s7_pointer x;
            for (x = cadr(args); is_pair(x); x = cdr(x))
                if (!is_string(car(x)))
                    return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *load-path* to ~S", 27), cadr(args))));
            if (is_null(x))
                return(cadr(args));
        }
        return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *load-path* to ~S", 27), cadr(args))));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rbx
movq 0x110(%rdi), %rax
cmpq %rax, %rbx
je 0x8638e
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, (%rbx)
jne 0x86322
cmpb $0x1, (%rbx)
movq %rbx, %rcx
jne 0x862a8
movq %rbx, %rcx
movq 0x8(%rcx), %rdx
cmpb $0x13, (%rdx)
jne 0x862b0
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0x86296
cmpq %rax, %rcx
setne %al
jmp 0x8631e
movq 0xea8(%r14), %rbx
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x9eb59(%rip), %rcx     # 0x124e35
movq %rcx, 0x10(%rax)
movq $0x1b, 0x8(%rax)
movq 0x10(%r15), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%r14), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b366
xorl %eax, %eax
testb %al, %al
je 0x8638e
movq 0xea8(%r14), %rbx
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x9eae7(%rip), %rcx     # 0x124e35
movq %rcx, 0x10(%rax)
movq $0x1b, 0x8(%rax)
movq 0x10(%r15), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%r14), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_cload_directory_set
static s7_pointer g_cload_directory_set(s7_scheme *sc, s7_pointer args)
    {
        /* this sets the directory for cload.scm's output */
        s7_pointer cl_dir;
        cl_dir = cadr(args);
        if (!is_string(cl_dir))
            return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *cload-directory* to ~S", 33), cadr(args))));
        s7_symbol_set_value(sc, sc->cload_directory_symbol, cl_dir);
        if (safe_strlen(string_value(cl_dir)) > 0)
            s7_add_to_load_path(sc, (const char *)(string_value(cl_dir)));
        /* should this remove the previous *cload-directory* name first? or not affect *load-path* at all? */
        return(cl_dir);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rbx
cmpb $0x13, (%rbx)
jne 0x863f4
movq 0xdf8(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xcdac
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x86460
cmpb $0x0, (%rsi)
je 0x86460
movq $-0x1, %rax
cmpb $0x0, 0x1(%rsi,%rax)
leaq 0x1(%rax), %rax
jne 0x863da
testq %rax, %rax
jle 0x86460
movq %r14, %rdi
callq 0x3886a
jmp 0x86460
movq 0xea8(%r14), %rbx
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x9ea31(%rip), %rcx     # 0x124e51
movq %rcx, 0x10(%rax)
movq $0x21, 0x8(%rax)
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%r14), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_libraries_set
static s7_pointer g_libraries_set(s7_scheme *sc, s7_pointer args) /* *libraries* setter */
    {
        s7_pointer nf;
        nf = cadr(args);
        if (is_null(nf))
            return(sc->nil);
        if (is_pair(nf))
        {
            s7_pointer p;
            if (s7_list_length(sc, nf) <= 0)
                return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *libraries* to ~S", 27), nf)));
            for (p = nf; is_pair(p); p = cdr(p))
                if ((!is_pair(car(p))) ||
                        (!is_string(caar(p))) ||
                        (!is_let(cdar(p))))
                    return(simple_wrong_type_argument_with_type(sc, sc->libraries_symbol, car(p), wrap_string(sc, "a list of conses of the form (string . let)", 43)));
            return(nf);
        }
        return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *libraries* to ~S", 27), nf)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
movq 0x110(%rdi), %r15
cmpq %r15, %r14
je 0x86756
movq %rdi, %rbx
cmpb $0x1, (%r14)
jne 0x866f3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c299
testq %rax, %rax
jle 0x866f3
cmpb $0x1, (%r14)
jne 0x866ee
movq %r14, %rax
movq 0x8(%rax), %rdx
cmpb $0x1, (%rdx)
jne 0x8675f
movq 0x8(%rdx), %rcx
cmpb $0x13, (%rcx)
jne 0x8675f
movq 0x10(%rdx), %rcx
cmpb $0x1c, (%rcx)
jne 0x8675f
movq 0x10(%rax), %rax
cmpb $0x1, (%rax)
je 0x866c2
movq %r14, %r15
jmp 0x86756
movq 0xea8(%rbx), %r15
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%rbx)
leaq 0x9e755(%rip), %rcx     # 0x124e73
movq %rcx, 0x10(%rax)
movq $0x1b, 0x8(%rax)
movq 0x6e0(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r14, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b366
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x1250(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x140(%rbx), %rcx
movq 0x820(%rbx), %rax
movslq 0x7dc(%rbx), %rdi
movq (%rax,%rdi,8), %r8
leal 0x1(%rdi), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rbx)
leaq 0x9e6f9(%rip), %rax     # 0x124e8f
movq %rax, 0x10(%r8)
movq $0x2b, 0x8(%r8)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_sharp_readers_set
static s7_pointer g_sharp_readers_set(s7_scheme *sc, s7_pointer args)
    {
        /* new value must be either () or a proper list of conses (char . func) */
        if (is_null(cadr(args))) return(cadr(args));
        if (is_pair(cadr(args)))
        {
            s7_pointer x;
            for (x = cadr(args); is_pair(x); x = cdr(x))
                if ((!is_pair(car(x))) ||
                        (!s7_is_character(caar(x))) ||
                        (!s7_is_procedure(cdar(x))))
                    return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *#readers* to ~S", 26), cadr(args))));
            if (is_null(x))
                return(cadr(args));
        }
        return(s7_error(sc, sc->error_symbol, set_elist_2(sc, wrap_string(sc, "can't set *#readers* to ~S", 26), cadr(args))));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rbx
movq 0x110(%rdi), %rax
cmpq %rax, %rbx
je 0x86b81
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, (%rbx)
jne 0x86b15
cmpb $0x1, (%rbx)
movq %rbx, %rcx
jne 0x86a9b
leaq 0xcd8cc(%rip), %rdx     # 0x154330
movq %rbx, %rcx
movq 0x8(%rcx), %rsi
cmpb $0x1, (%rsi)
jne 0x86aa3
movq 0x8(%rsi), %rdi
cmpb $0x8, (%rdi)
jne 0x86aa3
movq 0x10(%rsi), %rsi
movzbl (%rsi), %edi
cmpb $0x0, (%rdi,%rdx)
jne 0x86a92
cmpb $0x14, %dil
jne 0x86aa3
testb $0x20, 0x2(%rsi)
je 0x86aa3
movq 0x10(%rcx), %rcx
cmpb $0x1, (%rcx)
je 0x86a67
cmpq %rax, %rcx
setne %al
jmp 0x86b11
movq 0xea8(%r14), %rbx
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x9e429(%rip), %rcx     # 0x124ef8
movq %rcx, 0x10(%rax)
movq $0x1a, 0x8(%rax)
movq 0x10(%r15), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%r14), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b366
xorl %eax, %eax
testb %al, %al
je 0x86b81
movq 0xea8(%r14), %rbx
movq 0x820(%r14), %rax
movslq 0x7dc(%r14), %rcx
movq (%rax,%rcx,8), %rax
incl %ecx
andl $0x7, %ecx
movl %ecx, 0x7dc(%r14)
leaq 0x9e3b7(%rip), %rcx     # 0x124ef8
movq %rcx, 0x10(%rax)
movq $0x1a, 0x8(%rax)
movq 0x10(%r15), %rcx
movq 0x8(%rcx), %rcx
movq 0x6e0(%r14), %rdx
movq %rax, 0x8(%rdx)
movq 0x6e0(%r14), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x6e0(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b366
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_set_outlet
static s7_pointer g_set_outlet(s7_scheme *sc, s7_pointer args)
    {
        /* (let ((a 1)) (let ((b 2)) (set! (outlet (curlet)) (rootlet)) ((curlet) 'a))) */
        s7_pointer env, new_outer;

        env = car(args);
        if (!is_let(env))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 1, env, "a let"));
        if ((is_immutable(env)) || (env == sc->s7_let))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 1, env, "a mutable let"));

        new_outer = cadr(args);
        if (!is_let(new_outer))
            return(s7_wrong_type_arg_error(sc, "set! outlet", 2, new_outer, "a let"));

        if (env != sc->rootlet)
            set_outlet(env, (new_outer == sc->rootlet) ? sc->nil : new_outer);
        return(new_outer);
    }

// Assembly:
movq 0x8(%rsi), %rcx
cmpb $0x1c, (%rcx)
jne 0x86c14
testb $0x1, 0x3(%rcx)
jne 0x86c24
cmpq 0x2150(%rdi), %rcx
je 0x86c24
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
cmpb $0x1c, (%rax)
jne 0x86c3c
movq 0x150(%rdi), %rsi
cmpq %rsi, %rcx
je 0x86c13
movq %rax, %rdx
cmpq %rsi, %rax
jne 0x86c0f
movq 0x110(%rdi), %rdx
movq %rdx, 0x10(%rcx)
retq
leaq 0x9e2f8(%rip), %rsi     # 0x124f13
leaq 0x995fd(%rip), %r8      # 0x12021f
jmp 0x86c32
leaq 0x9e2e8(%rip), %rsi     # 0x124f13
leaq 0x9d843(%rip), %r8      # 0x124475
movl $0x1, %edx
jmp 0xe25f
leaq 0x9e2d0(%rip), %rsi     # 0x124f13
leaq 0x995d5(%rip), %r8      # 0x12021f
movl $0x2, %edx
movq %rax, %rcx
jmp 0xe25f
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_set_port_line_number
static s7_pointer g_set_port_line_number(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer p, line;

        if ((is_null(car(args))) ||
                ((is_null(cdr(args))) && (is_t_integer(car(args)))))
            p = sc->input_port;
        else
        {
            p = car(args);
            if (!(is_input_port(p)))
                return(s7_wrong_type_arg_error(sc, "set! port-line-number", 1, p, "an input port"));
        }

        line = (is_null(cdr(args)) ? car(args) : cadr(args));
        if (!is_t_integer(line))
            return(s7_wrong_type_arg_error(sc, "set! port-line-number", 2, line, "an integer"));
        port_line_number(p) = integer(line);
        return(line);
    }

// Assembly:
movq 0x8(%rsi), %rcx
movq 0x110(%rdi), %rax
cmpq %rax, %rcx
je 0x86c72
cmpq %rax, 0x10(%rsi)
jne 0x86c7b
cmpb $0xb, (%rcx)
jne 0x86c7b
movq 0x170(%rdi), %rcx
jmp 0x86c80
cmpb $0x23, (%rcx)
jne 0x86cba
movq 0x10(%rsi), %rdx
cmpq %rax, %rdx
cmoveq %rsi, %rdx
movq 0x8(%rdx), %rax
cmpb $0xb, (%rax)
jne 0x86c9f
movl 0x8(%rax), %edx
movq 0x8(%rcx), %rcx
movl %edx, 0x20(%rcx)
retq
leaq 0x9e279(%rip), %rsi     # 0x124f1f
leaq 0x993b5(%rip), %r8      # 0x120062
movl $0x2, %edx
movq %rax, %rcx
jmp 0xe25f
leaq 0x9e25e(%rip), %rsi     # 0x124f1f
leaq 0x8d907(%rip), %r8      # 0x1145cf
movl $0x1, %edx
jmp 0xe25f
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: g_set_port_position
static s7_pointer g_set_port_position(s7_scheme *sc, s7_pointer args)
    {
        s7_pointer port, pos;
        s7_int position;

        port = car(args);
        if (!(is_input_port(port)))
            return(s7_wrong_type_arg_error(sc, "set! port-position", 1, port, "an input port"));
        if (port_is_closed(port))
            return(s7_wrong_type_arg_error(sc, "set! port-position", 1, port, "an open input port"));

        pos = cadr(args);
        if (!is_t_integer(pos))
            return(s7_wrong_type_arg_error(sc, "set! port-position", 2, pos, "an integer"));
        position = s7_integer(pos);
        if (position < 0)
            return(out_of_range(sc, sc->port_position_symbol, small_int(2), pos, its_negative_string));

        if (is_string_port(port))
            port_position(port) = position;
#if (!MS_WINDOWS)
        else
        {
            if (is_file_port(port))
            {
                rewind(port_file(port));
                fseek(port_file(port), (long)position, SEEK_SET);
            }
        }
#endif
        return(pos);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rsi), %r14
cmpb $0x23, (%r14)
jne 0x86cfb
movq 0x8(%r14), %rax
cmpb $0x1, 0x2(%rax)
jne 0x86d1b
leaq 0x9e243(%rip), %rsi     # 0x124f35
leaq 0x9d85b(%rip), %r8      # 0x124554
jmp 0x86d09
leaq 0x9e233(%rip), %rsi     # 0x124f35
leaq 0x8d8c6(%rip), %r8      # 0x1145cf
movl $0x1, %edx
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xe25f
movq 0x10(%rsi), %rcx
movq 0x8(%rcx), %rbx
cmpb $0xb, (%rbx)
jne 0x86d4e
movq 0x8(%rbx), %r15
testq %r15, %r15
js 0x86d66
movl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0x86dbe
cmpl $0x1, %ecx
jne 0x86dd9
movq %r15, 0x20(%r14)
jmp 0x86dd9
leaq 0x9e1e0(%rip), %rsi     # 0x124f35
leaq 0x99306(%rip), %r8      # 0x120062
movl $0x2, %edx
movq %rbx, %rcx
jmp 0x86d11
movq 0x1400(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc7be8(%rip), %rcx     # 0x14e960
movq 0xcbcc9(%rip), %rdx     # 0x152a48
movq 0x1ee8(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ee8(%rdi), %rdx
movq %rbx, %rsi
callq 0x3b366
jmp 0x86dd9
movq 0x8(%rax), %rdi
callq 0x91e0
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x9500
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: float_vector_ref_d_7pii
static s7_double float_vector_ref_d_7pii(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2)
                {
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                            return(float_vector(v, i2 + (i1 * vector_offset(v, 0))));
                        out_of_range(sc, sc->float_vector_ref_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->float_vector_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x871b4
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %r14, (%rdx)
jle 0x871b4
testq %rcx, %rcx
js 0x8713b
cmpq %rcx, 0x8(%rdx)
jle 0x8713b
movq 0x18(%rax), %rax
imulq (%rax), %r14
shlq $0x3, %r14
addq 0x10(%rsi), %r14
movsd (%r14,%rcx,8), %xmm0
jmp 0x87230
movq 0xef0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc781b(%rip), %rdx     # 0x14e968
movq 0x1f00(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0x1ee8(%rbx), %rsi
testq %rcx, %rcx
leaq 0xcb8df(%rip), %rcx     # 0x152a48
leaq 0xcb8d0(%rip), %rdi     # 0x152a40
cmovsq %rcx, %rdi
movq 0x1f00(%rbx), %rcx
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
movq 0xef0(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc779a(%rip), %rcx     # 0x14e960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xcb866(%rip), %rsi     # 0x152a48
leaq 0xcb857(%rip), %rdi     # 0x152a40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: float_vector_set_d_7piid
static s7_double float_vector_set_d_7piid(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2, s7_double x)
                {
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                        {
                            float_vector(v, i2 + (i1 * vector_offset(v, 0))) = x;
                            return(x);
                        }
                        out_of_range(sc, sc->float_vector_set_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->float_vector_set_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(x);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x873b0
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %r14, (%rdx)
jle 0x873b0
testq %rcx, %rcx
js 0x87337
cmpq %rcx, 0x8(%rdx)
jle 0x87337
movq 0x18(%rax), %rax
imulq (%rax), %r14
shlq $0x3, %r14
addq 0x10(%rsi), %r14
movsd (%rsp), %xmm0
movsd %xmm0, (%r14,%rcx,8)
jmp 0x87429
movq 0xef8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc761f(%rip), %rdx     # 0x14e968
movq 0x1f00(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0x1ee8(%rbx), %rsi
testq %rcx, %rcx
leaq 0xcb6e3(%rip), %rcx     # 0x152a48
leaq 0xcb6d4(%rip), %rdi     # 0x152a40
cmovsq %rcx, %rdi
movq 0x1f00(%rbx), %rcx
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
movq 0xef8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc759e(%rip), %rcx     # 0x14e960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xcb66a(%rip), %rsi     # 0x152a48
leaq 0xcb65b(%rip), %rdi     # 0x152a40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: int_vector_ref_i_7pi
static s7_int int_vector_ref_i_7pi(s7_scheme *sc, s7_pointer v, s7_int i)
                {
                    if ((i >= 0) && (i < vector_length(v)))
                        return(int_vector(v, i));
                    out_of_range(sc, sc->int_vector_ref_symbol, small_int(2), wrap_integer1(sc, i), (i < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
testq %rdx, %rdx
js 0x876b3
cmpq %rdx, 0x8(%rsi)
jle 0x876b3
movq 0x10(%rsi), %rax
movq (%rax,%rdx,8), %rax
retq
pushq %rax
movq 0xfa8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc729a(%rip), %rcx     # 0x14e960
movq 0x1f00(%rdi), %rsi
movq %rdx, 0x8(%rsi)
movq 0x1ee8(%rdi), %rsi
testq %rdx, %rdx
leaq 0xcb366(%rip), %rdx     # 0x152a48
leaq 0xcb357(%rip), %r8      # 0x152a40
cmovsq %rdx, %r8
movq 0x1f00(%rdi), %rdx
movq (%r8), %r8
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x3b366
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: int_vector_ref_i_7pii
static s7_int int_vector_ref_i_7pii(s7_scheme *sc, s7_pointer v, s7_int i1, s7_int i2)
                {
                    if ((i1 >= 0) && (i1 < vector_dimension(v, 0)))
                    {
                        if ((i2 >= 0) && (i2 < vector_dimension(v, 1)))
                            return(int_vector(v, i2 + (i1 * vector_offset(v, 0))));
                        out_of_range(sc, sc->int_vector_ref_symbol, small_int(3), wrap_integer1(sc, i2), (i2 < 0) ? its_negative_string : its_too_large_string);
                    }
                    out_of_range(sc, sc->int_vector_ref_symbol, small_int(2), wrap_integer1(sc, i1), (i1 < 0) ? its_negative_string : its_too_large_string);
                    return(0);
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rdx, %rdx
js 0x877f5
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdx
cmpq %r14, (%rdx)
jle 0x877f5
testq %rcx, %rcx
js 0x8777c
cmpq %rcx, 0x8(%rdx)
jle 0x8777c
movq 0x18(%rax), %rax
imulq (%rax), %r14
shlq $0x3, %r14
addq 0x10(%rsi), %r14
movq (%r14,%rcx,8), %rax
jmp 0x87870
movq 0xfa8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc71da(%rip), %rdx     # 0x14e968
movq 0x1f00(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0x1ee8(%rbx), %rsi
testq %rcx, %rcx
leaq 0xcb29e(%rip), %rcx     # 0x152a48
leaq 0xcb28f(%rip), %rdi     # 0x152a40
cmovsq %rcx, %rdi
movq 0x1f00(%rbx), %rcx
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
movq 0xfa8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0xc7159(%rip), %rcx     # 0x14e960
movq 0x1f00(%rbx), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rbx), %rdx
testq %r14, %r14
leaq 0xcb225(%rip), %rsi     # 0x152a48
leaq 0xcb216(%rip), %rdi     # 0x152a40
cmovsq %rsi, %rdi
movq 0x1f00(%rbx), %rsi
movq (%rdi), %rdi
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdi, 0x8(%rax)
movq 0x1948(%rbx), %rsi
movq 0x1ee8(%rbx), %rdx
movq %rbx, %rdi
callq 0x3b366
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/BernardTatin[P]s7sh/s7.c
// Function: int_vector_set_i_7pii
static s7_int int_vector_set_i_7pii(s7_scheme *sc, s7_pointer v, s7_int i, s7_int x)
                {
                    if ((i < 0) || (i >= vector_length(v)))
                        out_of_range(sc, sc->int_vector_set_symbol, small_int(2), wrap_integer1(sc, i), (i < 0) ? its_negative_string : its_too_large_string);
                    int_vector(v, i) = x;
                    return(x);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rdx, %rdx
js 0x87a6f
cmpq %r14, 0x8(%r15)
jg 0x87ae5
testq %r14, %r14
movq 0xfb0(%rdi), %rax
movq 0x8(%rax), %rax
movq 0xc6edc(%rip), %rcx     # 0x14e960
movq 0x1f00(%rdi), %rdx
movq %r14, 0x8(%rdx)
movq 0x1ee8(%rdi), %rdx
leaq 0xcafab(%rip), %rsi     # 0x152a48
leaq 0xcaf9c(%rip), %r8      # 0x152a40
cmovsq %rsi, %r8
movq 0x1f00(%rdi), %rsi
movq (%r8), %r8
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %r8, 0x8(%rax)
movq 0x1948(%rdi), %rsi
movq 0x1ee8(%rdi), %rdx
callq 0x3b366
movq 0x10(%r15), %rax
movq %rbx, (%rax,%r14,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq