LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: format_method
static bool format_method(s7_scheme *sc, const char *str, format_data *fdat, s7_pointer port)
    {
        s7_pointer func, obj;
        char ctrl_str[3];

        obj = car(fdat->args);
        if ((!has_active_methods(sc, obj)) ||
                ((func = find_method(sc, find_let(sc, obj), sc->format_symbol)) == sc->undefined))
            return(false);

        ctrl_str[0] = '~';
        ctrl_str[1] = str[0];
        ctrl_str[2] = '\0';
        s7_apply_function(sc, func, list_3(sc, port, s7_make_string_wrapper(sc, ctrl_str), obj));

        fdat->args = cdr(fdat->args);
        fdat->ctr++;
        return(true);
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0xd6839
movq 0x88(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0xd6839
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x9a10
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movq 0x88(%rsp), %rax
movq 0xf20(%rax), %rdx
callq 0x98d0
movq %rax, 0x68(%rsp)
movq 0x88(%rsp), %rcx
cmpq 0x128(%rcx), %rax
jne 0xd6846
movb $0x0, 0x97(%rsp)
jmp 0xd69b8
movb $0x7e, 0x5d(%rsp)
movq 0x80(%rsp), %rax
movb (%rax), %al
movb %al, 0x5e(%rsp)
movb $0x0, 0x5f(%rsp)
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x88(%rsp), %rdi
leaq 0x5d(%rsp), %rsi
callq 0x145e0
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x88(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xd68fa
movq 0x88(%rsp), %rdi
callq 0xc670
movq 0x88(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdx
callq 0xd9f0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0xd9f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x78(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x78(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x97(%rsp)
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: format_numeric_arg
static s7_int format_numeric_arg(s7_scheme *sc, const char *str, s7_int str_len, format_data *fdat, s7_int *i)
    {
        s7_int width, old_i;
        old_i = *i;
        width = format_read_integer(i, str_len, str);
        if (width < 0)
        {
            if (str[old_i - 1] != ',') /* need branches here, not if-expr because just_format_error creates the permanent string */
                just_format_error(sc, "width is negative?", 18, str, fdat->args, fdat);
            else just_format_error(sc, "precision is negative?", 22, str, fdat->args, fdat);
        }
        else
        {
            if (width > sc->max_format_length)
            {
                if (str[old_i - 1] != ',')
                    just_format_error(sc, "width is too big", 16, str, fdat->args, fdat);
                else just_format_error(sc, "precision is too big", 20, str, fdat->args, fdat);
            }
        }
        return(width);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xd7640
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jge 0xd6abd
movq 0x48(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
je 0xd6a78
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x11802b(%rip), %rsi    # 0x1eea77
movl $0x12, %edx
callq 0xb880
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x38(%rsp), %r8
callq 0xd5620
jmp 0xd6ab8
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x117ffc(%rip), %rsi    # 0x1eea8a
movl $0x16, %edx
callq 0xb880
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x38(%rsp), %r8
callq 0xd5620
jmp 0xd6b6f
movq 0x28(%rsp), %rax
movq 0x50(%rsp), %rcx
cmpq 0x2c0(%rcx), %rax
jle 0xd6b6d
movq 0x48(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
je 0xd6b2d
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x117fa0(%rip), %rsi    # 0x1eeaa1
movl $0x10, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x38(%rsp), %r8
callq 0xd5620
jmp 0xd6b6b
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
leaq 0x117f70(%rip), %rsi    # 0x1eeab2
movl $0x14, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x38(%rsp), %r8
callq 0xd5620
jmp 0xd6b6d
jmp 0xd6b6f
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: format_n_arg
static s7_int format_n_arg(s7_scheme *sc, const char *str, format_data *fdat, s7_pointer args)
    {
        s7_int n;

        if (is_null(fdat->args))          /* (format #f "~nT") */
            just_format_error(sc, "~~N: missing argument", 21, str, args, fdat);
        if (!s7_is_integer(car(fdat->args)))
            just_format_error(sc, "~~N: integer argument required", 30, str, args, fdat);
        n = s7_integer(car(fdat->args));

        if (n < 0)
            just_format_error(sc, "~~N value is negative?", 22, str, args, fdat);
        else
        {
            if (n > sc->max_format_length)
                just_format_error(sc, "~~N value is too big", 20, str, args, fdat);
        }
        fdat->args = cdr(fdat->args);    /* I don't think fdat->ctr should be incremented here -- it's for *vector-print-length* etc */
        return(n);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x110(%rcx), %rax
jne 0xd6beb
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x117f02(%rip), %rsi    # 0x1eeac7
movl $0x15, %edx
callq 0xb880
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0xd5620
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x11340
testb $0x1, %al
jne 0xd6c3d
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x117ec6(%rip), %rsi    # 0x1eeadd
movl $0x1e, %edx
callq 0xb880
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0xd5620
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x10790
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jge 0xd6c9a
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x117e8a(%rip), %rsi    # 0x1eeafc
movl $0x16, %edx
callq 0xb880
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0xd5620
jmp 0xd6ce9
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq 0x2c0(%rcx), %rax
jle 0xd6ce7
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
leaq 0x117e51(%rip), %rsi    # 0x1eeb13
movl $0x14, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0xd5620
jmp 0xd6ce9
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: format_append_chars
static void format_append_chars(s7_scheme *sc, format_data *fdat, char pad, s7_int chars, s7_pointer port)
    {
        if (is_string_port(port))
        {
            if ((port_position(port) + chars) < port_data_size(port))
            {
                local_memset((char *)port_data(port) + port_position(port), pad, chars);
                port_position(port) += chars;
            }
            else
            {
                s7_int new_len;
                new_len = port_position(port) + chars;
                resize_port_data(sc, port, new_len * 2);
                local_memset((char *)port_data(port) + port_position(port), pad, chars);
                port_position(port) = new_len;
            }
            fdat->loc += chars;
            sc->format_column += chars;
        }
        else
        {
            block_t *b;
            char *str;
            b = mallocate(sc, chars + 1);
            str = (char *)block_data(b);
            local_memset((void *)str, pad, chars);
            str[chars] = '\0';
            format_append_string(sc, fdat, str, chars, port);
            liberate(sc, b);
        }
    }

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb %al, 0x37(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0xd6e18
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
addq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jge 0xd6d91
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rax
addq 0x20(%rax), %rdi
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rdx
movzbl %al, %esi
callq 0xc85e0
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0xd6dec
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
shlq %rdx
callq 0xcf4e0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rax
addq 0x20(%rax), %rdi
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rdx
movzbl %al, %esi
callq 0xc85e0
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rdx
movq 0x40(%rsp), %rax
movslq 0x238(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x238(%rax)
jmp 0xd6e8e
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x1, %rsi
callq 0xaa80
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movb 0x37(%rsp), %al
movq 0x28(%rsp), %rdx
movzbl %al, %esi
callq 0xc85e0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xd5800
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb230
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: set_elist_4
static s7_pointer set_elist_4(s7_scheme *sc, s7_pointer x1, s7_pointer x2, s7_pointer x3, s7_pointer x4)
    {
        s7_pointer p;
        p = sc->elist_4;
        set_car(p, x1); p = cdr(p);
        set_car(p, x2); p = cdr(p);
        set_car(p, x3); p = cdr(p);
        set_car(p, x4);
        return(sc->elist_4);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq 0x6f0(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x6f0(%rax), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: set_elist_5
static s7_pointer set_elist_5(s7_scheme *sc, s7_pointer x1, s7_pointer x2, s7_pointer x3, s7_pointer x4, s7_pointer x5)
    {
        s7_pointer p;
        p = sc->elist_5;
        set_car(p, x1); p = cdr(p);
        set_car(p, x2); p = cdr(p);
        set_car(p, x3); p = cdr(p);
        set_car(p, x4); p = cdr(p);
        set_car(p, x5);
        return(sc->elist_5);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x8(%rsp), %rax
movq 0x6f8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x10(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x18(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x20(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x28(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rcx
movq -0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x6f8(%rax), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: s7_string_to_list
static s7_pointer s7_string_to_list(s7_scheme *sc, const char *str, s7_int len)
    {
        s7_int i;
        s7_pointer result;
        if (len == 0)
            return(sc->nil);
        check_heap_size(sc, len);
        sc->v = sc->nil;
        for (i = len - 1; i >= 0; i--)
            sc->v = cons_unchecked(sc, s7_make_character(sc, ((uint8_t)str[i])), sc->v);
        result = sc->v;
        sc->v = sc->nil;
        return(result);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xd72d1
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0xd7399
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x34cc0
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jl 0xd7366
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x14410
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rax
movq 0x4d0(%rax), %rdx
callq 0xd9f0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xd7306
movq 0x28(%rsp), %rax
movq 0x4d0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_to_list
static s7_pointer byte_vector_to_list(s7_scheme *sc, const uint8_t *str, s7_int len)
                {
                    s7_int i;
                    s7_pointer p;
                    if (len == 0) return(sc->nil);
                    sc->w = sc->nil;
                    for (i = len - 1; i >= 0; i--)
                        sc->w = cons(sc, small_int((uint32_t)(str[i])), sc->w);
                    p = sc->w;
                    sc->w = sc->nil;
                    return(p);
                }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xd73e1
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0xd7516
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x38(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jl 0xd74e3
movq 0x40(%rsp), %rax
movq 0x30(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x13f054(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xd746a
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0xd7407
movq 0x48(%rsp), %rax
movq 0x4d8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: format_read_integer
static s7_int format_read_integer(s7_int *cur_i, s7_int str_len, const char *str)
    {
        /* we know that str[*cur_i] is a digit */
        s7_int i, lval = 0;
        for (i = *cur_i; i < str_len - 1; i++)
        {
            int32_t dig;
            dig = digits[(uint8_t)str[i]];
            if (dig < 10)
            {
#if HAVE_OVERFLOW_CHECKS
                if ((multiply_overflow(lval, 10, &lval)) ||
                        (add_overflow(lval, dig, &lval)))
                    break;
#else
                lval = dig + (lval * 10);
#endif
            }
            else break;
        }
        *cur_i = i;
        return(lval);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0xd76e5
movq 0x146319(%rip), %rax    # 0x21d998
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rsp)
cmpl $0xa, -0x2c(%rsp)
jge 0xd76d1
movl $0xa, %ecx
imulq -0x28(%rsp), %rcx
seto %al
movq %rcx, -0x28(%rsp)
testb $0x1, %al
jne 0xd76cd
movq -0x28(%rsp), %rcx
movslq -0x2c(%rsp), %rax
addq %rax, %rcx
seto %al
movq %rcx, -0x28(%rsp)
testb $0x1, %al
jne 0xd76cd
jmp 0xd76cf
jmp 0xd76e5
jmp 0xd76d3
jmp 0xd76e5
jmp 0xd76d5
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xd7665
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: tree_is_cyclic_or_has_pairs
static int tree_is_cyclic_or_has_pairs(s7_scheme *sc, s7_pointer tree)
    {
        s7_pointer fast, slow;
        bool has_pairs = false;

        if (!is_pair(tree)) return(TREE_NOT_CYCLIC);
        slow = tree;
        fast = tree;
        while (true)
        {
            if (tree_is_collected(fast)) return(TREE_CYCLIC);
            if ((!has_pairs) &&
                    (is_unquoted_pair(car(fast))))
                has_pairs = true;
            fast = cdr(fast);
            if (!is_pair(fast))
            {
                if (!has_pairs) return(TREE_NOT_CYCLIC);
                break;
            }
            if (tree_is_collected(fast)) return(TREE_CYCLIC);
            if ((!has_pairs) &&
                    (is_unquoted_pair(car(fast))))
                has_pairs = true;
            fast = cdr(fast);
            if (!is_pair(fast))
            {
                if (!has_pairs) return(TREE_NOT_CYCLIC);
                break;
            }
            slow = cdr(slow);
            if (fast == slow) return(TREE_CYCLIC);
        }
#if S7_DEBUGGING
        if (!has_pairs) fprintf(stderr, "at end but no pairs: %s\n", DISPLAY(tree));
#endif
        return(TREE_HAS_PAIRS);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movb $0x0, -0x29(%rsp)
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xd7729
movl $0x0, -0x4(%rsp)
jmp 0xd787c
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xd775b
movl $0x1, -0x4(%rsp)
jmp 0xd787c
testb $0x1, -0x29(%rsp)
jne 0xd7793
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xd7793
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
je 0xd7793
movb $0x1, -0x29(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xd77c7
testb $0x1, -0x29(%rsp)
jne 0xd77c2
movl $0x0, -0x4(%rsp)
jmp 0xd787c
jmp 0xd7874
movq -0x20(%rsp), %rax
movzwl 0x6(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xd77e5
movl $0x1, -0x4(%rsp)
jmp 0xd787c
testb $0x1, -0x29(%rsp)
jne 0xd781d
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xd781d
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x17b0(%rcx), %rax
je 0xd781d
movb $0x1, -0x29(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xd784b
testb $0x1, -0x29(%rsp)
jne 0xd7849
movl $0x0, -0x4(%rsp)
jmp 0xd787c
jmp 0xd7874
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jne 0xd786f
movl $0x1, -0x4(%rsp)
jmp 0xd787c
jmp 0xd773d
movl $0x2, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_big_list
static s7_pointer make_big_list(s7_scheme *sc, int32_t len, s7_pointer init)
                {
                    s7_pointer result;
                    int32_t i;

                    check_heap_size(sc, len);
                    sc->v = sc->nil;
                    for (i = 0; i < len; i++)
                        sc->v = cons_unchecked(sc, init, sc->v);
                    result = sc->v;
                    sc->v = sc->nil;
                    return(result);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x34cc0
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0xd7ca2
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x4d0(%rax), %rdx
callq 0xd9f0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xd7c61
movq 0x20(%rsp), %rax
movq 0x4d0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4d0(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: memclr64
static void memclr64(void *p, size_t bytes)
    {
        size_t i, n;
        int64_t *vals;
        vals = (int64_t *)p;
        n = bytes >> 3;
        for (i = 0; i < n; )
            LOOP_8(vals[i++] = 0);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0xd7e12
jmp 0xd7d1d
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movq $0x0, (%rax,%rcx,8)
jmp 0xd7d0b
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: int_vector_setter
static s7_pointer int_vector_setter(s7_scheme *sc, s7_pointer vec, s7_int loc, s7_pointer val)
                {
                    if (s7_is_integer(val))
                        int_vector(vec, loc) = s7_integer(val);
                    else s7_wrong_type_arg_error(sc, "int-vector-set!", 3, val, "an integer");
                    return(val);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0xd7f28
jmp 0xd7f49
movq 0x8(%rsp), %rdi
callq 0x10790
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xd7f6b
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rcx
leaq 0x112500(%rip), %rsi    # 0x1ea45a
movl $0x3, %edx
leaq 0x116ccc(%rip), %r8     # 0x1eec32
callq 0x12540
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_setter
static s7_pointer byte_vector_setter(s7_scheme *sc, s7_pointer str, s7_int loc, s7_pointer val)
                {
                    if (s7_is_integer(val))
                    {
                        s7_int byte;
                        byte = s7_integer(val);
                        if ((byte >= 0) && (byte < 256))
                        {
                            byte_vector(str, loc) = (uint8_t)byte;
                            return(val);
                        }
                        return(s7_wrong_type_arg_error(sc, "byte-vector-set!", 3, val, "a byte"));
                    }
                    return(s7_wrong_type_arg_error(sc, "byte-vector-set!", 3, val, "an integer"));
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0xd8088
jmp 0xd80f7
movq 0x10(%rsp), %rdi
callq 0x10790
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jl 0xd80ce
cmpq $0x100, 0x8(%rsp)       # imm = 0x100
jge 0xd80ce
movq 0x8(%rsp), %rax
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xd811e
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rcx
leaq 0x112549(%rip), %rsi    # 0x1ea628
movl $0x3, %edx
leaq 0x116a9c(%rip), %r8     # 0x1eeb87
callq 0x12540
movq %rax, 0x30(%rsp)
jmp 0xd811e
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rcx
leaq 0x112520(%rip), %rsi    # 0x1ea628
movl $0x3, %edx
leaq 0x116b1e(%rip), %r8     # 0x1eec32
callq 0x12540
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: byte_vector_fill
static void byte_vector_fill(s7_scheme *sc, s7_pointer vec, uint8_t byte)
                {
                    s7_int len;
                    len = vector_length(vec);
                    if (len == 0) return;
                    if (byte == 0)
                        memclr((void *)(byte_vector_bytes(vec)), len);
                    else local_memset((void *)(byte_vector_bytes(vec)), byte, len);
                }

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xd859c
jmp 0xd85d5
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0xd85bb
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xd2340
jmp 0xd85d5
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movb 0x17(%rsp), %al
movq 0x8(%rsp), %rdx
movzbl %al, %esi
callq 0xc85e0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_type_name
static const char *make_type_name(s7_scheme *sc, const char *name, article_t article)
                {
                    s7_int i, slen, len;

                    slen = safe_strlen(name);
                    len = slen + 8;
                    if (len > sc->typnam_len)
                    {
                        if (sc->typnam) free(sc->typnam);
                        sc->typnam = (char *)malloc(len);
                        sc->typnam_len = len;
                    }
                    if (article == INDEFINITE_ARTICLE)
                    {
                        i = 1;
                        sc->typnam[0] = 'a';
                        if ((name[0] == 'a') || (name[0] == 'e') || (name[0] == 'i') || (name[0] == 'o') || (name[0] == 'u'))
                            sc->typnam[i++] = 'n';
                        sc->typnam[i++] = ' ';
                    }
                    else i = 0;
                    memcpy((void *)(sc->typnam + i), (void *)name, slen);
                    sc->typnam[i + slen] = '\0';
                    return(sc->typnam);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa430
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movslq 0x480(%rcx), %rcx
cmpq %rcx, %rax
jle 0xd8920
movq 0x30(%rsp), %rax
cmpq $0x0, 0x478(%rax)
je 0xd88f5
movq 0x30(%rsp), %rax
movq 0x478(%rax), %rdi
callq 0x9050
movq 0x8(%rsp), %rdi
callq 0x9480
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x478(%rax)
movq 0x8(%rsp), %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x480(%rax)
cmpl $0x1, 0x24(%rsp)
jne 0xd89c8
movq $0x1, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x478(%rax), %rax
movb $0x61, (%rax)
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
je 0xd8984
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x65, %eax
je 0xd8984
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x69, %eax
je 0xd8984
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x6f, %eax
je 0xd8984
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x75, %eax
jne 0xd89a5
movq 0x30(%rsp), %rax
movq 0x478(%rax), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movb $0x6e, (%rax,%rcx)
movq 0x30(%rsp), %rax
movq 0x478(%rax), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movb $0x20, (%rax,%rcx)
jmp 0xd89d1
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x478(%rax), %rdi
addq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x93e0
movq 0x30(%rsp), %rax
movq 0x478(%rax), %rax
movq 0x18(%rsp), %rcx
addq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x30(%rsp), %rax
movq 0x478(%rax), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: typed_vector_typer_name
static const char *typed_vector_typer_name(s7_scheme *sc, s7_pointer p)
                {
                    s7_pointer typer;
                    typer = typed_vector_typer(p);
                    if (is_c_function(typer))
                        return(c_function_name(typer));
                    return(symbol_name(typed_vector_typer_symbol(sc, p)));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xd8a5c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xd8a78
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd8a90
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 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: typed_vector_typer_symbol
static s7_pointer typed_vector_typer_symbol(s7_scheme *sc, s7_pointer p)
                {
                    s7_pointer typer;
                    typer = typed_vector_typer(p);
                    if (is_c_function(typer))
                        return(c_function_symbol(typer));
                    return(find_closure(sc, typer, closure_let(typer)));
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xd8acd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xd8aea
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0xd8b00
movq %rax, 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: find_closure
static s7_pointer find_closure(s7_scheme *sc, s7_pointer closure, s7_pointer cur_env)
    {
        s7_pointer e, y;
        for (e = cur_env; is_let(e); e = outlet(e))
        {
            if (is_funclet(e))
            {
                s7_pointer sym, f;
                sym = funclet_function(e);
                f = s7_symbol_local_value(sc, sym, e);
                if (f == closure)
                    return(sym);
            }

            for (y = let_slots(e); tis_slot(y); y = next_slot(y))
                if (slot_value(y) == closure)
                    return(slot_symbol(y));
        }
        return(sc->nil);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1c, %eax
jne 0xd8be0
movq 0x20(%rsp), %rax
movq (%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0xd8b83
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xfe00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x30(%rsp), %rax
jne 0xd8b81
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xd8bf1
jmp 0xd8b83
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xd8bcb
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x30(%rsp), %rax
jne 0xd8bb9
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0xd8bf1
jmp 0xd8bbb
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xd8b91
jmp 0xd8bcd
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xd8b1d
movq 0x38(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: set_wlist_3
static s7_pointer set_wlist_3(s7_pointer lst, s7_pointer x1, s7_pointer x2, s7_pointer x3)
    {
        s7_pointer p;
        p = lst;
        set_car(p, x1); p = cdr(p);
        set_car(p, x2); p = cdr(p);
        set_car(p, x3);
        return(lst);
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_multivector
static inline s7_pointer make_multivector(s7_scheme *sc, s7_pointer vec, s7_pointer x)
                {
                    vdims_t *v;
                    v = list_to_dims(sc, x);
                    vdims_original(v) = sc->F;
                    vector_set_dimension_info(vec, v);
                    add_multivector(sc, vec);
                    return(vec);
                }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd9260
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x120(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x790(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x11230
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: list_to_dims
static inline vdims_t *list_to_dims(s7_scheme *sc, s7_pointer x)
                {
                    s7_int i, offset, len;
                    s7_pointer y;
                    vdims_t *v;
                    s7_int *ds, *os;

                    len = safe_list_length(x);
                    v = (vdims_t *)mallocate(sc, len * 2 * sizeof(s7_int));
                    vdims_rank(v) = len;
                    vdims_offsets(v) = (s7_int *)(vdims_dims(v) + len);
                    vector_elements_should_be_freed(v) = false;
                    ds = vdims_dims(v);
                    os = vdims_offsets(v);

                    for (i = 0, y = x; is_not_null(y); i++, y = cdr(y))
                        ds[i] = s7_integer(car(y));

                    for (i = len - 1, offset = 1; i >= 0; i--)
                    {
                        os[i] = offset;
                        offset *= ds[i];
                    }
                    return(v);
                }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a070
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
shlq %rsi
shlq $0x3, %rsi
callq 0xaa80
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq $0x0, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0xd9349
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x10790
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xd92f9
movq 0x20(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x30(%rsp)
movq $0x1, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jl 0xd93a3
movq 0x28(%rsp), %rdx
movq (%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
imulq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0xd9360
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_float_location
static s7_int hash_float_location(s7_double x)
                {
#if defined(__clang__)
                    if (is_NaN(x)) return(0);
#endif
                    x = fabs(x);
                    if (x < 100.0)
                        return(1000.0 * x);     /* this means hash_table_float_epsilon only works if it is less than about .001 */
                    return((s7_int)x);
                }

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x13860
testb $0x1, %al
jne 0xd93cb
jmp 0xd93d6
movq $0x0, 0x10(%rsp)
jmp 0xd9423
movsd 0x8(%rsp), %xmm0
movaps 0x1086bd(%rip), %xmm1   # 0x1e1aa0
pand %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10867b(%rip), %xmm0   # 0x1e1a70
ucomisd 0x8(%rsp), %xmm0
jbe 0xd9417
movsd 0x108673(%rip), %xmm0   # 0x1e1a78
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x10(%rsp)
jmp 0xd9423
cvttsd2si 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_float_1
static hash_entry_t *hash_float_1(s7_scheme *sc, s7_pointer table, s7_int loc, s7_double keyval)
                {
                    hash_entry_t *x;
                    if (is_NaN(keyval))
                    {
                        for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                            if ((is_t_real(hash_entry_key(x))) &&       /* we're possibly called from hash_equal, so keys might not be T_REAL */
                                    (is_NaN(real(hash_entry_key(x)))))
                                return(x);
                    }
                    else
                    {
                        for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                            if (is_t_real(hash_entry_key(x)))
                            {
                                s7_double val;
                                val = real(hash_entry_key(x));
                                if ((val == keyval) ||                  /* inf case */
                                        (fabs(val - keyval) < sc->hash_table_float_epsilon))
                                    return(x);
                            }
                    }
                    return(sc->unentry);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x13860
testb $0x1, %al
jne 0xd94ca
jmp 0xd9537
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd9532
movq 0x8(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xd9520
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
callq 0x13860
testb $0x1, %al
jne 0xd9511
jmp 0xd9520
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xd95e8
jmp 0xd9522
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xd94e1
jmp 0xd95d7
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd95d5
movq 0x8(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0xd95c0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jne 0xd9589
jp 0xd9589
jmp 0xd95b2
movsd (%rsp), %xmm1
subsd 0x10(%rsp), %xmm1
movaps 0x108505(%rip), %xmm0   # 0x1e1aa0
pand %xmm0, %xmm1
movq 0x28(%rsp), %rax
movsd 0x268(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd95be
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xd95e8
jmp 0xd95c0
jmp 0xd95c2
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xd954e
jmp 0xd95d7
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_complex_1
static hash_entry_t *hash_complex_1(s7_scheme *sc, s7_pointer table, s7_int loc, s7_pointer key)
                {
                    hash_entry_t *x;
                    for (x = hash_table_element(table, loc); x; x = hash_entry_next(x))
                        if ((is_t_complex(hash_entry_key(x))) &&
                                (s7_is_equivalent(sc, hash_entry_key(x), key)))
                            return(x);
                    return(sc->unentry);
                }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd9682
movq 0x8(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xe, %eax
jne 0xd9670
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x3e930
testb $0x1, %al
jne 0xd9664
jmp 0xd9670
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xd9693
jmp 0xd9672
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xd962f
movq 0x28(%rsp), %rax
movq 0x490(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_c_string
static char *make_permanent_c_string(s7_scheme *sc, const char *str)
    {
        char *x;
        s7_int len;
        len = safe_strlen(str);
        x = (char *)alloc_permanent_string(sc, len + 1);
        memcpy((void *)x, (void *)str, len);
        x[len] = 0;
        return(x);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa430
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0x14930
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x93e0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_table_typer_symbol
static s7_pointer hash_table_typer_symbol(s7_scheme *sc, s7_pointer typer)
                {
                    if (typer == sc->T)
                        return(sc->T);
                    if (is_c_function(typer))
                        return(c_function_symbol(typer));
                    return(find_closure(sc, typer, closure_let(typer)));
                }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x118(%rcx), %rax
jne 0xd97d2
movq 0x8(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xd980c
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xd97f1
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xd980c
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq (%rsp), %rax
movq 0x18(%rax), %rdx
callq 0xd8b00
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)