LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: complex_invert
static s7_pointer complex_invert(s7_scheme *sc, s7_pointer p)
    {
        s7_double r2, i2, den;
        r2 = real_part(p);
        i2 = imag_part(p);
        den = (r2 * r2 + i2 * i2);
        return(s7_make_complex(sc, r2 / den, -i2 / den));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
divsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
divsd (%rsp), %xmm1
callq 0x122a0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: nan_with_error_check
static s7_pointer nan_with_error_check(s7_scheme *sc, s7_pointer y, s7_pointer p, s7_pointer args, s7_pointer caller)
    {
        for (; is_not_null(p); p = cdr(p))
            if (!is_real_via_method(sc, car(p)))
                return(wrong_type_argument(sc, caller, position_of(p, args), car(p), T_REAL));
        return(y);
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq 0x58(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x1c107b
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11360
testb $0x1, %al
jne 0x1c1066
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1c0f5b
movq 0x58(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1c0f5b
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1c1090
testb $0x1, %al
jne 0x1c1066
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xc5450
cltq
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1c0fb0
movq 0x30(%rsp), %rcx
leaq 0x554da(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x1c1026
jmp 0x1c0fb2
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c0fd6
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%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 $0xb, (%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x58(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x5959e(%rip), %r9      # 0x21a5f8
callq 0xc560
movq %rax, 0x60(%rsp)
jmp 0x1c1085
jmp 0x1c1068
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
jmp 0x1c0eed
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_real_via_method_1
static bool is_real_via_method_1(s7_scheme *sc, s7_pointer p)
    {
        s7_pointer f;
        f = find_method(sc, find_let(sc, p), sc->is_real_symbol);
        if (f != sc->undefined)
            return(is_true(sc, s7_apply_function(sc, f, cons(sc, p, sc->nil))));
        return(false);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rax
movq 0x1180(%rax), %rdx
callq 0x98d0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x1c11bd
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c113e
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xda50
movq 0x48(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0x1c11c2
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: c_quo_int
static inline s7_int c_quo_int(s7_scheme *sc, s7_int x, s7_int y)
    {
        if (y == 0)
            division_by_zero_error(sc, sc->quotient_symbol, set_elist_2(sc, wrap_integer1(sc, x), wrap_integer2(sc, y)));
        if ((y == -1) && (x == s7_int_min))   /* (quotient most-negative-fixnum -1) */
            simple_out_of_range(sc, sc->quotient_symbol, set_elist_2(sc, wrap_integer1(sc, x), wrap_integer2(sc, y)), its_too_large_string);
        return(x / y);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x1c1257
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq 0x1418(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x12430
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1721c0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0xb830
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rax, %rdx
callq 0x123b0
cmpq $-0x1, 0x40(%rsp)
jne 0x1c12e6
movq 0x48(%rsp), %rax
cmpq 0x592e9(%rip), %rax     # 0x21a558
jne 0x1c12e6
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq 0x1418(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x12430
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1721c0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xb830
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
movq 0x5928f(%rip), %rcx     # 0x21a570
callq 0x45240
movq 0x48(%rsp), %rax
cqto
idivq 0x40(%rsp)
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: c_mod
static s7_int c_mod(s7_int x, s7_int y)
    {
        s7_int z;
        if (y == 0) return(x);     /* else arithmetic exception */
        if ((y == 1) || (y == -1)) /* else (modulo most-negative-fixnum -1) will segfault with arithmetic exception */
            return(0);
        z = x % y;
        if (((y < 0) && (z > 0)) ||
                ((y > 0) && (z < 0)))
            return(z + y);
        return(z);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x1c167e
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1c16e5
cmpq $0x1, -0x18(%rsp)
je 0x1c168e
cmpq $-0x1, -0x18(%rsp)
jne 0x1c1699
movq $0x0, -0x8(%rsp)
jmp 0x1c16e5
movq -0x10(%rsp), %rax
cqto
idivq -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jge 0x1c16ba
cmpq $0x0, -0x20(%rsp)
jg 0x1c16ca
cmpq $0x0, -0x18(%rsp)
jle 0x1c16db
cmpq $0x0, -0x20(%rsp)
jge 0x1c16db
movq -0x20(%rsp), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x1c16e5
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_number_via_method
static bool is_number_via_method(s7_scheme *sc, s7_pointer p)
    {
        if (s7_is_number(p))
            return(true);
        if (has_active_methods(sc, p))
        {
            s7_pointer f;
            f = find_method(sc, find_let(sc, p), sc->is_number_symbol);
            if (f != sc->undefined)
                return(is_true(sc, s7_apply_function(sc, f, cons(sc, p, sc->nil))));
        }
        return(false);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11320
testb $0x1, %al
jne 0x1c170e
jmp 0x1c1718
movb $0x1, 0x57(%rsp)
jmp 0x1c1868
movq 0x40(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1c1863
movq 0x48(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1c1863
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rax
movq 0x1120(%rax), %rdx
callq 0x98d0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x1c1861
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c17e2
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xda50
movq 0x48(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0x1c1868
jmp 0x1c1863
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: c_ash
static s7_int c_ash(s7_scheme *sc, s7_int arg1, s7_int arg2)
    {
        if (arg1 == 0) return(0);

        if (arg2 >= s7_int_bits)
        {
            if ((arg1 == -1) && (arg2 == 63))   /* (ash -1 63): most-negative-fixnum */
                return(s7_int_min);
            out_of_range(sc, sc->ash_symbol, small_int(2), wrap_integer1(sc, arg2), its_too_large_string);
        }

        if (arg2 < -s7_int_bits)
        {
            if (arg1 < 0)                      /* (ash -31 -100) */
                return(-1);
            return(0);
        }

        /* I can't see any point in protecting this: (ash 9223372036854775807 1) -> -2, but anyone using ash must know something about bits */
        if (arg2 >= 0)
        {
            if (arg1 < 0)
            {
                uint64_t z;
                z = (uint64_t)arg1;
                return((s7_int)(z << arg2));
            }
            return(arg1 << arg2);
        }
        return(arg1 >> -arg2);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x1c18a9
movq $0x0, 0x40(%rsp)
jmp 0x1c19bc
movq 0x28(%rsp), %rax
movslq 0x58edb(%rip), %rcx     # 0x21a790
cmpq %rcx, %rax
jl 0x1c1933
cmpq $-0x1, 0x30(%rsp)
jne 0x1c18db
cmpq $0x3f, 0x28(%rsp)
jne 0x1c18db
movq 0x58c87(%rip), %rax     # 0x21a558
movq %rax, 0x40(%rsp)
jmp 0x1c19bc
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0xbd8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x54b8f(%rip), %rax     # 0x216490
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x12430
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
movq 0x58c42(%rip), %r8      # 0x21a570
callq 0x13880
movq 0x28(%rsp), %rax
xorl %ecx, %ecx
subl 0x58e50(%rip), %ecx     # 0x21a790
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x1c1966
cmpq $0x0, 0x30(%rsp)
jge 0x1c195b
movq $-0x1, 0x40(%rsp)
jmp 0x1c19bc
movq $0x0, 0x40(%rsp)
jmp 0x1c19bc
cmpq $0x0, 0x28(%rsp)
jl 0x1c19a8
cmpq $0x0, 0x30(%rsp)
jge 0x1c1994
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq %cl, %rax
movq %rax, 0x40(%rsp)
jmp 0x1c19bc
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq %cl, %rax
movq %rax, 0x40(%rsp)
jmp 0x1c19bc
movq 0x30(%rsp), %rax
xorl %ecx, %ecx
subq 0x28(%rsp), %rcx
sarq %cl, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: integer_length
static int32_t integer_length(s7_int a)
    {
#define I_8 256LL
#define I_16 65536LL
#define I_24 16777216LL
#define I_32 4294967296LL
#define I_40 1099511627776LL
#define I_48 281474976710656LL
#define I_56 72057594037927936LL

        /* a might be most-negative-fixnum! in Clisp: (integer-length -9223372036854775808) -> 63
        */
        if (a < 0)
        {
            if (a == s7_int_min) return(63);
            a = -a;
        }
        if (a < I_8) return(bits[a]);
        if (a < I_16) return(8 + bits[a >> 8]);
        if (a < I_24) return(16 + bits[a >> 16]);
        if (a < I_32) return(24 + bits[a >> 24]);
        if (a < I_40) return(32 + bits[a >> 32]);
        if (a < I_48) return(40 + bits[a >> 40]);
        if (a < I_56) return(48 + bits[a >> 48]);
        return(56 + bits[a >> 56]);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jge 0x1c1fe4
movq -0x10(%rsp), %rax
cmpq 0x5858f(%rip), %rax     # 0x21a558
jne 0x1c1fd8
movl $0x3f, -0x4(%rsp)
jmp 0x1c212c
xorl %eax, %eax
subq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
cmpq $0x100, -0x10(%rsp)     # imm = 0x100
jge 0x1c2007
movq -0x10(%rsp), %rcx
leaq 0x1f245(%rip), %rax     # 0x1e1240
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rsp)
jmp 0x1c212c
cmpq $0x10000, -0x10(%rsp)   # imm = 0x10000
jge 0x1c2031
movq -0x10(%rsp), %rcx
sarq $0x8, %rcx
leaq 0x1f21e(%rip), %rax     # 0x1e1240
movl (%rax,%rcx,4), %eax
addl $0x8, %eax
movl %eax, -0x4(%rsp)
jmp 0x1c212c
cmpq $0x1000000, -0x10(%rsp) # imm = 0x1000000
jge 0x1c205b
movq -0x10(%rsp), %rcx
sarq $0x10, %rcx
leaq 0x1f1f4(%rip), %rax     # 0x1e1240
movl (%rax,%rcx,4), %eax
addl $0x10, %eax
movl %eax, -0x4(%rsp)
jmp 0x1c212c
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, -0x10(%rsp)
jge 0x1c208b
movq -0x10(%rsp), %rcx
sarq $0x18, %rcx
leaq 0x1f1c4(%rip), %rax     # 0x1e1240
movl (%rax,%rcx,4), %eax
addl $0x18, %eax
movl %eax, -0x4(%rsp)
jmp 0x1c212c
movabsq $0x10000000000, %rax    # imm = 0x10000000000
cmpq %rax, -0x10(%rsp)
jge 0x1c20b8
movq -0x10(%rsp), %rcx
sarq $0x20, %rcx
leaq 0x1f194(%rip), %rax     # 0x1e1240
movl (%rax,%rcx,4), %eax
addl $0x20, %eax
movl %eax, -0x4(%rsp)
jmp 0x1c212c
movabsq $0x1000000000000, %rax  # imm = 0x1000000000000
cmpq %rax, -0x10(%rsp)
jge 0x1c20e5
movq -0x10(%rsp), %rcx
sarq $0x28, %rcx
leaq 0x1f167(%rip), %rax     # 0x1e1240
movl (%rax,%rcx,4), %eax
addl $0x28, %eax
movl %eax, -0x4(%rsp)
jmp 0x1c212c
movabsq $0x100000000000000, %rax # imm = 0x100000000000000
cmpq %rax, -0x10(%rsp)
jge 0x1c2112
movq -0x10(%rsp), %rcx
sarq $0x30, %rcx
leaq 0x1f13a(%rip), %rax     # 0x1e1240
movl (%rax,%rcx,4), %eax
addl $0x30, %eax
movl %eax, -0x4(%rsp)
jmp 0x1c212c
movq -0x10(%rsp), %rcx
sarq $0x38, %rcx
leaq 0x1f11e(%rip), %rax     # 0x1e1240
movl (%rax,%rcx,4), %eax
addl $0x38, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_string_to_number_1
static s7_pointer g_string_to_number_1(s7_scheme *sc, s7_pointer args, s7_pointer caller)
    {
        s7_int radix;
        char *str;

        if (!is_string(car(args)))
            return(method_or_bust(sc, car(args), caller, args, T_STRING, 1));

        if (is_pair(cdr(args)))
        {
            s7_pointer rad;
            rad = cadr(args);
            if (!s7_is_integer(rad))
                return(method_or_bust(sc, rad, caller, args, T_INTEGER, 2));
            radix = s7_integer(rad);
            if ((radix < 2) || (radix > 16))
                return(out_of_range(sc, caller, small_int(2), rad, a_valid_radix_string));
        }
        else radix = 10;
        str = (char *)string_value(car(args));
        if ((!str) || (!(*str)))
            return(sc->F);

        return(string_to_number(sc, str, radix));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x1c2197
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x30(%rsp)
jmp 0x1c229f
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c2244
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x11340
testb $0x1, %al
jne 0x1c21f8
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0xb, %r8d
movl $0x2, %r9d
callq 0x13c50
movq %rax, 0x30(%rsp)
jmp 0x1c229f
movq (%rsp), %rdi
callq 0x10790
movq %rax, 0x10(%rsp)
cmpq $0x2, 0x10(%rsp)
jl 0x1c2216
cmpq $0x10, 0x10(%rsp)
jle 0x1c2242
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x54265(%rip), %rdx     # 0x216490
movq (%rsp), %rcx
movq 0x62faa(%rip), %r8      # 0x2251e0
callq 0x13880
movq %rax, 0x30(%rsp)
jmp 0x1c229f
jmp 0x1c224d
movq $0xa, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1c2271
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x1c2284
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1c229f
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0x1c22b0
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: string_to_number
static s7_pointer string_to_number(s7_scheme *sc, char *str, int32_t radix)
    {
        s7_pointer x;
        x = make_atom(sc, str, radix, NO_SYMBOLS, WITHOUT_OVERFLOW_ERROR);
        if (s7_is_number(x))  /* only needed because str might start with '#' and not be a number (#t for example) */
            return(x);
        return(sc->F);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0xca470
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x11320
testb $0x1, %al
jne 0x1c22ee
jmp 0x1c22f9
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c230a
movq 0x18(%rsp), %rax
movq 0x120(%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: char_with_error_check
static s7_pointer char_with_error_check(s7_scheme *sc, s7_pointer x, s7_pointer args, s7_pointer caller)
    {
        s7_pointer y;
        for (y = cdr(x); is_pair(y); y = cdr(y)) /* before returning #f, check for bad trailing arguments */
            if (!is_character_via_method(sc, car(y)))
                return(wrong_type_argument(sc, caller, position_of(y, args), car(y), T_CHARACTER));
        return(sc->F);
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c2492
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1c24b0
testb $0x1, %al
jne 0x1c247d
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xc5450
cltq
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1c23c7
movq 0x30(%rsp), %rcx
leaq 0x540c3(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x1c243d
jmp 0x1c23c9
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c23ed
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%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 $0xb, (%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x58(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x5815f(%rip), %r9      # 0x21a5d0
callq 0xc560
movq %rax, 0x60(%rsp)
jmp 0x1c24a3
jmp 0x1c247f
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x1c2346
movq 0x58(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_character_via_method
static bool is_character_via_method(s7_scheme *sc, s7_pointer p)
    {
        if (s7_is_character(p))
            return(true);
        if (has_active_methods(sc, p))
        {
            s7_pointer f;
            f = find_method(sc, find_let(sc, p), sc->is_char_symbol);
            if (f != sc->undefined)
                return(is_true(sc, s7_apply_function(sc, f, cons(sc, p, sc->nil))));
        }
        return(false);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x1c24ce
jmp 0x1c24d8
movb $0x1, 0x57(%rsp)
jmp 0x1c2628
movq 0x40(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1c2623
movq 0x48(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1c2623
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rax
movq 0x1020(%rax), %rdx
callq 0x98d0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x1c2621
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c25a2
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xda50
movq 0x48(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0x1c2628
jmp 0x1c2623
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_char_cmp
static s7_pointer g_char_cmp(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!s7_is_character(y))
            return(method_or_bust(sc, y, sym, args, T_CHARACTER, 1));

        for (x = cdr(args); is_pair(x); x = cdr(x))
        {
            if (!s7_is_character(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_CHARACTER, position_of(x, args)));
            if (charcmp(character(y), character(car(x))) != val)
                return(char_with_error_check(sc, x, args, sym));
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq %rcx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x1c26a2
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x60(%rsp), %rcx
movl $0x8, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x70(%rsp)
jmp 0x1c283b
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c282a
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14430
testb $0x1, %al
jne 0x1c27c6
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c2731
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xc5450
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rsp), %rcx
movl %eax, %r9d
movl $0x8, %r8d
callq 0x13c50
movq %rax, 0x70(%rsp)
jmp 0x1c283b
movq 0x40(%rsp), %rax
movb 0x8(%rax), %cl
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movzbl %cl, %edi
movzbl 0x8(%rax), %esi
callq 0x1c2850
cmpl 0x5c(%rsp), %eax
je 0x1c2809
movq 0x68(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x1c2320
movq %rax, 0x70(%rsp)
jmp 0x1c283b
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
jmp 0x1c26b0
movq 0x68(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: is_string_via_method
static bool is_string_via_method(s7_scheme *sc, s7_pointer p)
    {
        if (s7_is_string(p))
            return(true);
        if (has_active_methods(sc, p))
        {
            s7_pointer f;
            f = find_method(sc, find_let(sc, p), sc->is_string_symbol);
            if (f != sc->undefined)
                return(is_true(sc, s7_apply_function(sc, f, cons(sc, p, sc->nil))));
        }
        return(false);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x14460
testb $0x1, %al
jne 0x1c310e
jmp 0x1c3118
movb $0x1, 0x57(%rsp)
jmp 0x1c3268
movq 0x40(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1c3263
movq 0x48(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1c3263
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x9a10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rax
movq 0x1190(%rax), %rdx
callq 0x98d0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x1c3261
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c31e2
movq 0x48(%rsp), %rdi
callq 0xc670
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
callq 0xda50
movq 0x48(%rsp), %rcx
cmpq 0x120(%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x57(%rsp)
jmp 0x1c3268
jmp 0x1c3263
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_char_cmp_ci
static s7_pointer g_char_cmp_ci(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!s7_is_character(y))
            return(method_or_bust(sc, y, sym, args, T_CHARACTER, 1));

        for (x = cdr(args); is_pair(x); x = cdr(x))
        {
            if (!s7_is_character(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_CHARACTER, position_of(x, args)));
            if (charcmp(upper_character(y), upper_character(car(x))) != val)
                return(char_with_error_check(sc, x, args, sym));
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq %rcx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x14430
testb $0x1, %al
jne 0x1c3702
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x60(%rsp), %rcx
movl $0x8, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x70(%rsp)
jmp 0x1c389b
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c388a
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14430
testb $0x1, %al
jne 0x1c3826
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c3791
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xc5450
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rsp), %rcx
movl %eax, %r9d
movl $0x8, %r8d
callq 0x13c50
movq %rax, 0x70(%rsp)
jmp 0x1c389b
movq 0x40(%rsp), %rax
movb 0x9(%rax), %cl
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movzbl %cl, %edi
movzbl 0x9(%rax), %esi
callq 0x1c2850
cmpl 0x5c(%rsp), %eax
je 0x1c3869
movq 0x68(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x1c2320
movq %rax, 0x70(%rsp)
jmp 0x1c389b
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
jmp 0x1c3710
movq 0x68(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: scheme_strequal_ci
static bool scheme_strequal_ci(s7_pointer s1, s7_pointer s2)
    {
        /* same as scheme_strcmp -- watch out for unwanted sign! */
        s7_int i, len, len2;
        uint8_t *str1, *str2;

        len = string_length(s1);
        len2 = string_length(s2);
        if (len != len2)
            return(false);

        str1 = (uint8_t *)string_value(s1);
        str2 = (uint8_t *)string_value(s2);

        for (i = 0; i < len; i++)
            if (uppers[(int32_t)str1[i]] != uppers[(int32_t)str2[i]])
                return(false);
        return(true);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x30(%rsp), %rax
je 0x1c3d4c
movb $0x0, -0x1(%rsp)
jmp 0x1c3dd7
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jge 0x1c3dd2
movq -0x38(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x5e9db(%rip), %rax     # 0x222770
movzbl (%rax,%rcx), %eax
movq -0x40(%rsp), %rcx
movq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rdx
leaq 0x5e9bf(%rip), %rcx     # 0x222770
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1c3dc0
movb $0x0, -0x1(%rsp)
jmp 0x1c3dd7
jmp 0x1c3dc2
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x1c3d71
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: string_check_method
static s7_pointer string_check_method(s7_scheme *sc, s7_pointer sym, s7_pointer x, s7_pointer y, s7_pointer args)
    {
        for (y = cdr(x); is_pair(y); y = cdr(y))
            if (!is_string_via_method(sc, car(y)))
                return(wrong_type_argument(sc, sym, position_of(y, args), car(y), T_STRING));
        return(sc->F);
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1c3f57
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1c30f0
testb $0x1, %al
jne 0x1c3f42
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xc5450
cltq
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0x1c3e8c
movq 0x30(%rsp), %rcx
leaq 0x525fe(%rip), %rax     # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x1c3f02
jmp 0x1c3e8e
movq 0x58(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c3eb2
movq 0x58(%rsp), %rdi
callq 0xc670
movq 0x58(%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 $0xb, (%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x58(%rsp), %rax
movq 0x140(%rax), %r8
movq 0x566f2(%rip), %r9      # 0x21a628
callq 0xc560
movq %rax, 0x60(%rsp)
jmp 0x1c3f68
jmp 0x1c3f44
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x1c3e0b
movq 0x58(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: scheme_strcasecmp
static int32_t scheme_strcasecmp(s7_pointer s1, s7_pointer s2)
    {
        /* same as scheme_strcmp -- watch out for unwanted sign! and lack of trailing null (length sets string end).
        */
        s7_int i, len, len1, len2;
        uint8_t *str1, *str2;

        len1 = string_length(s1);
        len2 = string_length(s2);
        if (len1 > len2)
            len = len2;
        else len = len1;

        str1 = (uint8_t *)string_value(s1);
        str2 = (uint8_t *)string_value(s2);

        for (i = 0; i < len; i++)
        {
            if (uppers[(int32_t)str1[i]] < uppers[(int32_t)str2[i]])
                return(-1);
            if (uppers[(int32_t)str1[i]] > uppers[(int32_t)str2[i]])
                return(1);
        }

        if (len1 < len2)
            return(-1);
        if (len1 > len2)
            return(1);
        return(0);
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x38(%rsp), %rax
jle 0x1c3fbe
movq -0x38(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x1c3fc8
movq -0x30(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
jge 0x1c40a1
movq -0x40(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x5e75b(%rip), %rax     # 0x222770
movzbl (%rax,%rcx), %eax
movq -0x48(%rsp), %rcx
movq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rdx
leaq 0x5e73f(%rip), %rcx     # 0x222770
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x1c4046
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1c40d5
movq -0x40(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x5e712(%rip), %rax     # 0x222770
movzbl (%rax,%rcx), %eax
movq -0x48(%rsp), %rcx
movq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rdx
leaq 0x5e6f6(%rip), %rcx     # 0x222770
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x1c408c
movl $0x1, -0x4(%rsp)
jmp 0x1c40d5
jmp 0x1c408e
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x1c3fed
movq -0x30(%rsp), %rax
cmpq -0x38(%rsp), %rax
jge 0x1c40b7
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1c40d5
movq -0x30(%rsp), %rax
cmpq -0x38(%rsp), %rax
jle 0x1c40cd
movl $0x1, -0x4(%rsp)
jmp 0x1c40d5
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: g_string_ci_cmp_not
static s7_pointer g_string_ci_cmp_not(s7_scheme *sc, s7_pointer args, int32_t val, s7_pointer sym)
    {
        s7_pointer x, y;

        y = car(args);
        if (!is_string(y))
            return(method_or_bust(sc, y, sym, args, T_STRING, 1));

        for (x = cdr(args); is_not_null(x); x = cdr(x))
        {
            if (!is_string(car(x)))
                return(method_or_bust(sc, car(x), sym, cons(sc, y, x), T_STRING, position_of(x, args)));
            if (scheme_strcasecmp(y, car(x)) == val)
                return(string_check_method(sc, sym, x, y, args));
            y = car(x);
        }
        return(sc->T);
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq %rcx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x1c4141
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x60(%rsp), %rcx
movl $0x13, %r8d
movl $0x1, %r9d
callq 0x13c50
movq %rax, 0x70(%rsp)
jmp 0x1c42da
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x68(%rsp), %rcx
cmpq 0x110(%rcx), %rax
je 0x1c42c9
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x13, %eax
je 0x1c426a
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x68(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1c41d5
movq 0x68(%rsp), %rdi
callq 0xc670
movq 0x68(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xc5450
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rsp), %rcx
movl %eax, %r9d
movl $0x13, %r8d
callq 0x13c50
movq %rax, 0x70(%rsp)
jmp 0x1c42da
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1c3f80
cmpl 0x5c(%rsp), %eax
jne 0x1c42a8
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x60(%rsp), %r8
callq 0x1c3de0
movq %rax, 0x70(%rsp)
jmp 0x1c42da
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
jmp 0x1c414f
movq 0x68(%rsp), %rax
movq 0x118(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: random_state_to_let
static s7_pointer random_state_to_let(s7_scheme *sc, s7_pointer obj)
                {
#if WITH_GMP
                    return(g_local_inlet(sc, 4, sc->value_symbol, obj, sc->type_symbol, sc->is_random_state_symbol));
#else
                    if (!sc->seed_symbol)
                    {
                        sc->seed_symbol = make_symbol(sc, "seed");
                        sc->carry_symbol = make_symbol(sc, "carry");
                    }
                    return(g_local_inlet(sc, 8, sc->value_symbol, obj,
                                sc->type_symbol, sc->is_random_state_symbol,
                                sc->seed_symbol, s7_make_integer(sc, random_seed(obj)),
                                sc->carry_symbol, s7_make_integer(sc, random_carry(obj))));
#endif
                }

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
cmpq $0x0, 0x1d60(%rax)
jne 0x1c4dee
movq 0x68(%rsp), %rdi
leaq 0x2e96e(%rip), %rsi     # 0x1f3728
callq 0xb400
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x1d60(%rax)
movq 0x68(%rsp), %rdi
leaq 0x2e953(%rip), %rsi     # 0x1f372d
callq 0xb400
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x1d68(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rax
movq 0x18b8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq 0x18c0(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq 0x1170(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x1d60(%rax), %rbx
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x120f0
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x1d68(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x120f0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x48(%rsp), %r9
movq 0x50(%rsp), %r11
movq 0x58(%rsp), %r10
movl $0x8, %esi
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x1c4750
addq $0x70, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: goto_to_let
static s7_pointer goto_to_let(s7_scheme *sc, s7_pointer obj)
                {
                    if (!sc->active_symbol)
                    {
                        sc->active_symbol = make_symbol(sc, "active");
                        sc->goto_symbol = make_symbol(sc, "goto?");
                    }
                    return(g_local_inlet(sc, 6, sc->value_symbol, obj,
                                sc->type_symbol, sc->goto_symbol,
                                sc->active_symbol, s7_make_boolean(sc, call_exit_active(obj))));
                }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
cmpq $0x0, 0x1d70(%rax)
jne 0x1c4f2d
movq 0x50(%rsp), %rdi
leaq 0x2e83a(%rip), %rsi     # 0x1f3733
callq 0xb400
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x1d70(%rax)
movq 0x50(%rsp), %rdi
leaq 0x2e821(%rip), %rsi     # 0x1f373a
callq 0xb400
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x1d78(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq 0x18b8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq 0x18c0(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq 0x1d78(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x1d70(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x9c10
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x38(%rsp), %r9
movq 0x40(%rsp), %r10
movl $0x6, %esi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1c4750
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: c_pointer_to_let
static s7_pointer c_pointer_to_let(s7_scheme *sc, s7_pointer obj)
                {
                    /* c_pointer_info can be a let and might have an object->let method (see c_object below) */
                    if (!sc->c_type_symbol)
                    {
                        sc->c_type_symbol = make_symbol(sc, "c-type");
                        sc->info_symbol = make_symbol(sc, "info");
                    }
                    return(g_local_inlet(sc, 10, sc->value_symbol, obj,
                                sc->type_symbol, sc->is_c_pointer_symbol,
                                sc->c_pointer_symbol, s7_make_integer(sc, (s7_int)((intptr_t)c_pointer(obj))),
                                sc->c_type_symbol, c_pointer_type(obj),
                                sc->info_symbol, c_pointer_info(obj)));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
cmpq $0x0, 0x1da0(%rax)
jne 0x1c56b2
movq 0x68(%rsp), %rdi
leaq 0x2e0c2(%rip), %rsi     # 0x1f3740
callq 0xb400
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x1da0(%rax)
movq 0x68(%rsp), %rdi
leaq 0x2c3de(%rip), %rsi     # 0x1f1a7c
callq 0xb400
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x1d98(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq 0x18b8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq 0x18c0(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x1000(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq 0xc48(%rax), %r15
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x120f0
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x58(%rsp), %r9
movq %rax, %r14
movq 0x68(%rsp), %rax
movq 0x1da0(%rax), %rbx
movq 0x60(%rsp), %rax
movq 0x10(%rax), %r11
movq 0x68(%rsp), %rax
movq 0x1d98(%rax), %r10
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movl $0xa, %esi
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x1c4750
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)