LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/context_switch1.c
// Function: child
static void *child(void *arg)
{
	struct args *a = arg;
	char c;
	int ret;

	while (1) {
		do {
			ret = read(a->fd1[READ], &c, 1);
		} while (ret != 1 && errno == EINTR);
		assert(ret == 1);

		do {
			ret = write(a->fd2[WRITE], &c, 1);
		} while (ret != 1 && errno == EINTR);
		assert(ret == 1);
	}

	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movl (%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x1170
cmpl $0x1, %eax
jne 0x1e4e
movl 0xc(%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x10d0
cmpl $0x1, %eax
je 0x1e19
callq 0x1070
cmpl $0x4, (%rax)
je 0x1e2d
jmp 0x1e77
callq 0x1070
cmpl $0x4, (%rax)
je 0x1e19
leaq 0x4b1(%rip), %rdi       # 0x2310
leaq 0x44d(%rip), %rsi       # 0x22b3
leaq 0x4ac(%rip), %rcx       # 0x2319
movl $0x1c, %edx
callq 0x1130
leaq 0x492(%rip), %rdi       # 0x2310
leaq 0x42e(%rip), %rsi       # 0x22b3
leaq 0x48d(%rip), %rcx       # 0x2319
movl $0x21, %edx
callq 0x1130
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/glob6.c
// Function: gnew
static const char **
gnew(const char **gav)
{
	size_t siz;
	ptrdiff_t gidx;
	const char **nav;
	static unsigned mult = 1;

	if (gavp == gave) {
		mult *= GAVMULT;
		gidx  = (ptrdiff_t)(gavp - gav);
		siz   = (size_t)((gidx + (GAVNEW * mult)) * sizeof(char *));
		if ((nav = realloc(gav, siz)) == NULL)
			err(SH_ERR, FMT1S, ERR_NOMEM);
		gav   = nav;
		gavp  = gav + gidx;
		gave  = &gav[gidx + (GAVNEW * mult) - 1];
	}
	return gav;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3a9d(%rip), %r14      # 0x5108
cmpq 0x3a9e(%rip), %r14      # 0x5110
jne 0x16e1
movl 0x3a7e(%rip), %eax      # 0x50f8
leal (%rax,%rax), %r15d
movl %r15d, 0x3a73(%rip)     # 0x50f8
subq %rbx, %r14
shll $0x8, %eax
leaq (%r14,%rax,8), %rsi
andq $-0x8, %rsi
movq %rbx, %rdi
callq 0x11a0
movq %rax, %rbx
testq %rax, %rax
jne 0x16c4
leaq 0x1b7f(%rip), %rsi      # 0x3229
leaq 0x1a78(%rip), %rdx      # 0x3129
movl $0x2, %edi
xorl %eax, %eax
callq 0x19b0
movl 0x3a34(%rip), %r15d     # 0x50f8
addq %rbx, %r14
movq %r14, 0x3a3a(%rip)      # 0x5108
shll $0x7, %r15d
leaq (%r14,%r15,8), %rax
addq $-0x8, %rax
movq %rax, 0x3a2f(%rip)      # 0x5110
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/glob6.c
// Function: gcat
static char *
gcat(const char *src1, const char *src2)
{
	size_t siz;
	char *b, buf[PATHMAX], c, *dst;
	const char *s;

	*buf = EOS, b = buf, s = src1;
	while ((c = *s++) != EOS) {
		if (b >= &buf[PATHMAX - 1])
			err(SH_ERR, FMT1S, strerror(ENAMETOOLONG));
		if ((c &= ASCII) == EOS) {
			*b++ = SLASH;
			break;
		}
		*b++ = c;
	}

	s = src2;
	do {
		if (b >= &buf[PATHMAX])
			err(SH_ERR, FMT1S, strerror(ENAMETOOLONG));
		*b++ = c = *s++;
	} while (c != EOS);

	siz = b - buf;
	gavtot += siz;
	if (gavtot > GAVMAX)
		err(SH_ERR, FMT1S, ERR_E2BIG);
	if ((dst = malloc(siz)) == NULL) {
		err(SH_ERR, FMT1S, ERR_NOMEM);
		/*NOTREACHED*/
	}

	(void)memcpy(dst, buf, siz);
	return dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rsi, %r14
movb $0x0, (%rsp)
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x1755
movq %rdi, %r15
leaq 0x1b17(%rip), %r12      # 0x3229
xorl %eax, %eax
movq %rax, %rbx
cmpq $0xfff, %rax            # imm = 0xFFF
jb 0x173b
movl $0x24, %edi
callq 0x11c0
movl $0x2, %edi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x19b0
andb $0x7f, %bpl
je 0x1759
movb %bpl, (%rsp,%rbx)
movb 0x1(%r15,%rbx), %bpl
leaq 0x1(%rbx), %rax
testb %bpl, %bpl
jne 0x1714
jmp 0x175d
xorl %ebx, %ebx
jmp 0x1760
movb $0x2f, (%rsp,%rbx)
incq %rbx
leaq 0x1ac2(%rip), %r15      # 0x3229
cmpq $0x1000, %rbx           # imm = 0x1000
jl 0x178c
movl $0x24, %edi
callq 0x11c0
movl $0x2, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x19b0
movb (%r14), %al
incq %r14
movb %al, (%rsp,%rbx)
incq %rbx
testb %al, %al
jne 0x1767
movq 0x3975(%rip), %rax      # 0x5118
addq %rbx, %rax
movq %rax, 0x396b(%rip)      # 0x5118
cmpq $0x100001, %rax         # imm = 0x100001
jb 0x17cf
leaq 0x1a6d(%rip), %rsi      # 0x3229
leaq 0x199d(%rip), %rdx      # 0x3160
movl $0x2, %edi
xorl %eax, %eax
callq 0x19b0
movq %rbx, %rdi
callq 0x1180
movq %rax, %r14
testq %rax, %rax
jne 0x17f9
leaq 0x1a43(%rip), %rsi      # 0x3229
leaq 0x193c(%rip), %rdx      # 0x3129
movl $0x2, %edi
xorl %eax, %eax
callq 0x19b0
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1150
movq %r14, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/err.c
// Function: err
void
err(int es, const char *msgfmt, ...)
{
	va_list va;

	if (msgfmt != NULL) {
		va_start(va, msgfmt);
		wmsg(FD2, msgfmt, va);
		va_end(va);
	}
	if (myerrexit == NULL) {
		fd_print(FD2, FMT1S, "err: Invalid myerrexit function pointer");
		abort();
	}

	(*myerrexit)(es);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1a09
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x1a3d
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movl $0x2, %edi
callq 0x1a75
movq 0x36dc(%rip), %rax      # 0x5120
testq %rax, %rax
je 0x1a56
movl %ebx, %edi
callq *%rax
addq $0xd0, %rsp
popq %rbx
retq
leaq 0x17cc(%rip), %rsi      # 0x3229
leaq 0x170e(%rip), %rdx      # 0x3172
movl $0x2, %edi
xorl %eax, %eax
callq 0x1b6a
callq 0x1050
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/err.c
// Function: wmsg
static void
wmsg(int wfd, const char *msgfmt, va_list va)
{
	char msg[MSGMAX];
	char fmt[FMTMAX];
	struct iovec ev[4];
	int i;

	i = snprintf(fmt, sizeof(fmt), "%s", msgfmt);
	if (i >= 1 && i < (int)sizeof(fmt)) {
		i = vsnprintf(msg, sizeof(msg), fmt, va);
		if (i >= 0 && i < (int)sizeof(msg)) {
			if (write(wfd, msg, strlen(msg)) == -1) {
				ev[0].iov_base = (char *)getmyname();
				ev[0].iov_len  = strlen(getmyname());
				ev[1].iov_base = ": ";
				ev[1].iov_len  = (size_t)2;
				ev[2].iov_base = ERR_WRITE;
				ev[2].iov_len  = strlen(ERR_WRITE);
				ev[3].iov_base = "\n";
				ev[3].iov_len  = (size_t)1;
				(void)writev(FD2, ev, 4);
			}
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x8d8, %rsp            # imm = 0x8D8
movq %rdx, %r14
movq %rsi, %rcx
movl %edi, %ebx
leaq 0x171b(%rip), %rdx      # 0x31a9
movq %rsp, %rdi
movl $0x41, %esi
xorl %eax, %eax
callq 0x10f0
decl %eax
cmpl $0x3f, %eax
ja 0x1b5f
leaq 0x90(%rsp), %rdi
movq %rsp, %rdx
movl $0x841, %esi            # imm = 0x841
movq %r14, %rcx
callq 0x1090
cmpl $0x840, %eax            # imm = 0x840
ja 0x1b5f
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0x10d0
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x10a0
cmpq $-0x1, %rax
jne 0x1b5f
movq 0x3633(%rip), %rax      # 0x5128
testq %rax, %rax
leaq 0x169b(%rip), %rdi      # 0x319a
cmovneq %rax, %rdi
leaq 0x50(%rsp), %rbx
movq %rdi, (%rbx)
callq 0x10d0
movq %rax, 0x8(%rbx)
leaq 0x16a8(%rip), %rax      # 0x31c3
movq %rax, 0x10(%rbx)
movq $0x2, 0x18(%rbx)
leaq 0x167e(%rip), %rax      # 0x31ac
movq %rax, 0x20(%rbx)
movq $0xc, 0x28(%rbx)
leaq 0x1694(%rip), %rax      # 0x31d5
movq %rax, 0x30(%rbx)
movq $0x1, 0x38(%rbx)
movl $0x2, %edi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x1080
addq $0x8d8, %rsp            # imm = 0x8D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/s3lase[P]v6shell/err.c
// Function: setmyname
void
setmyname(const char *s)
{
	const char *p;

	if (s != NULL && *s != EOS) {
		if ((p = strrchr(s, SLASH)) != NULL)
			p++;
		else
			p = s;
		if (*p == HYPHEN && *(p + 1) != EOS)
			p++;
		else if (*p == EOS)
			/* should never (but can) be true */
			p = MYNAME;
	} else
		/* should never (but can) be true */
		p = MYNAME;

	myname = p;
}

// Assembly:
leaq 0x1571(%rip), %rcx      # 0x31a1
testq %rdi, %rdi
je 0x1c75
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x1c74
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x1100
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %rbx, %rcx
movb (%rcx), %al
cmpb $0x2d, %al
jne 0x1c67
cmpb $0x0, 0x1(%rcx)
je 0x1c67
incq %rcx
jmp 0x1c74
testb %al, %al
leaq 0x1531(%rip), %rax      # 0x31a1
cmoveq %rax, %rcx
popq %rbx
movq %rcx, 0x34ac(%rip)      # 0x5128
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/shellaes128v2d5n64/ref/shellaes.c
// Function: shellaesDec
int shellaesDec(const u8 key[], const u8 nonce[], const u8 ad[], unsigned long long int adlen, const u8 c[], unsigned long long int ctlen, u8 p[], unsigned long long int* ptlen){

    u8 tag[16];
    int flag;

    memcpy(tag, c+*ptlen, byte_length_tag);

    flag=shellaesDecVef_fb(key, nonce, ad, adlen, c, *ptlen, p, tag);


    /*if the tag is valid, erase the padding bits*/
    if(flag){
        while(p[*ptlen-1]!=0x80){
            *ptlen=*ptlen-1;
        }

        *ptlen=*ptlen-1;
    }

    return flag;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x38(%rsp), %rbx
movq 0x30(%rsp), %r14
movq (%rbx), %r9
vmovups (%r8,%r9), %xmm0
movq %rsp, %rax
vmovaps %xmm0, (%rax)
pushq %rax
pushq %r14
callq 0x10e0
addq $0x10, %rsp
testl %eax, %eax
je 0x3dc5
movq (%rbx), %rdx
leaq -0x1(%rdx), %rcx
xorl %esi, %esi
cmpb -0x1(%r14,%rdx), %sil
jno 0x3daf
movq %rcx, %rsi
jmp 0x3dc2
xorl %edx, %edx
movq %rcx, (%rbx)
leaq -0x1(%rcx), %rsi
cmpb -0x1(%r14,%rcx), %dl
movq %rsi, %rcx
jno 0x3db1
movq %rsi, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: exec_ref_op32
F_UINT exec_ref_op(uint32_t *pfflags, FloatOpEnum op,
                   F_UINT a, F_UINT b, RoundingModeEnum rm)
{
    F_UINT r;
    float_status st;
    softfloat_float a1, b1, r1;

    softfloat_init_ctx(&st, rm);
    a1 = sf_to_softfloat(a);
    b1 = sf_to_softfloat(b);

    switch(op) {
    case OP_FADD:
        r1 = glue(glue(float, F_SIZE), _add)(a1, b1, &st);
        break;
    case OP_FMUL:
        r1 = glue(glue(float, F_SIZE), _mul)(a1, b1, &st);
        break;
    case OP_FDIV:
        r1 = glue(glue(float, F_SIZE), _div)(a1, b1, &st);
        break;
    case OP_FSQRT:
        r1 = glue(glue(float, F_SIZE), _sqrt)(a1, &st);
        break;
#if F_SIZE <= 64
    case OP_FMIN:
        r1 = glue(glue(float, F_SIZE), _minnum)(a1, b1, &st);
        break;
    case OP_FMAX:
        r1 = glue(glue(float, F_SIZE), _maxnum)(a1, b1, &st);
        break;
#endif
    default:
        abort();
    }
    r = softfloat_to_sf(r1);
    *pfflags = softfloat_to_fflags(&st);
    return r;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, 0x8(%rsp)
movw $0x0, 0xc(%rsp)
movl %r8d, %eax
leaq 0x14dc7(%rip), %rdi     # 0x160d0
movb (%rdi,%rax,4), %al
movb %al, 0x9(%rsp)
movb $0x1, 0xe(%rsp)
cmpl $0x5, %esi
ja 0x13dc
movl %esi, %eax
leaq 0x14ce9(%rip), %rsi     # 0x16010
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0xb042
jmp 0x139b
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0x14cdb
jmp 0x139b
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0xb59d
jmp 0x139b
leaq 0x8(%rsp), %rsi
movl %edx, %edi
callq 0xc12d
jmp 0x139b
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0xb431
jmp 0x139b
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0x14da0
movb 0xa(%rsp), %cl
movl %ecx, %edx
shlb $0x4, %dl
andb $0x10, %dl
leal (%rcx,%rcx), %esi
andb $0x8, %sil
orb %dl, %sil
movl %ecx, %edx
shrb %dl
andb $0x4, %dl
orb %sil, %dl
movl %ecx, %esi
shrb $0x3, %sil
andb $0x2, %sil
orb %dl, %sil
shrb $0x5, %cl
andb $0x1, %cl
orb %sil, %cl
movzbl %cl, %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfptest.c
// Function: softfloat_to_fflags
static uint32_t softfloat_to_fflags(float_status *st)
{
    uint32_t fflags;
    fflags = 0;
    if (st->float_exception_flags & float_flag_invalid)
        fflags |= FFLAG_INVALID_OP;
    if (st->float_exception_flags & float_flag_divbyzero)
        fflags |= FFLAG_DIVIDE_ZERO;
    if (st->float_exception_flags & float_flag_overflow)
        fflags |= FFLAG_OVERFLOW;
    if (st->float_exception_flags & float_flag_underflow)
        fflags |= FFLAG_UNDERFLOW;
    if (st->float_exception_flags & float_flag_inexact)
        fflags |= FFLAG_INEXACT;
    return fflags;
}

// Assembly:
movl %edi, %eax
shlb $0x4, %al
andb $0x10, %al
leal (%rdi,%rdi), %ecx
andb $0x8, %cl
orb %al, %cl
movl %edi, %eax
shrb %al
andb $0x4, %al
orb %cl, %al
movl %edi, %ecx
shrb $0x3, %cl
andb $0x2, %cl
orb %al, %cl
shrb $0x5, %dil
andb $0x1, %dil
orb %cl, %dil
movzbl %dil, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: test_op_all64
void test_op_all(F_UINT a, F_UINT b, RoundingModeEnum rm, int it)
{
    test_op(OP_FADD, a, b, rm, it);
    test_op(OP_FMUL, a, b, rm, it);
    test_op(OP_FDIV, a, b, rm, it);
    test_op(OP_FSQRT, a, b, rm, it);
#if F_SIZE <= 64
    test_op(OP_FMIN, a, b, rm, it);
#endif
#if F_SIZE <= 64
    test_op(OP_FMAX, a, b, rm, it);
#endif
    test_cmp(a, b, it);

#if F_SIZE >= 64
    test_cvt_sf32_sf(a, rm, it);
#endif
#if F_SIZE >= 128
    test_cvt_sf64_sf(a, rm, it);
#endif
    test_cvt_int_sf(a, rm, it);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x27a7
movl $0x1, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x27a7
movl $0x2, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x27a7
movl $0x3, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x27a7
movl $0x4, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x27a7
movl $0x5, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x27a7
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x362f
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x29bc
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2bde
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: test_float32
void test_float(int step)
{
    F_UINT a, b, c;
    int rm_count, i, j, k;
    RoundingModeEnum rm;

#ifdef USE_REF_X86
    rm_count = 4;
#else
    rm_count = 5;
#endif
    if (step == 0) {
        /* test all simple cases */
        for(i = 0; i < SPECIAL_COUNT; i++) {
            a = special_sf(i);
            for(j = 0; j < SPECIAL_COUNT; j++) {
                b = special_sf(j);
                for(rm = 0; rm < rm_count; rm++) {
                    test_op_all(a, b, rm, i * SPECIAL_COUNT + j);
                    for(k = 0; k < SPECIAL_COUNT; k++) {
                        c = special_sf(k);
                        test_fma(a, b, c, rm, (i * SPECIAL_COUNT + j) * SPECIAL_COUNT + k);
                    }
                }
            }
        }
    } else {
        for(i = 0; i < 1000; i++) {
            /* Note: we cannot test RM_RMM */
            a = rrandom_sf();
            b = rrandom_sf();
            c = rrandom_sf();
            for(rm = 0; rm < rm_count; rm++) {
                test_op_all(a, b, rm, i);
                test_fma(a, b, c, rm, i);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %ebx, %ebx
testl %edi, %edi
je 0x251a
callq 0x122b
movl %eax, %ebp
callq 0x122b
movl %eax, %r14d
callq 0x122b
movl %eax, %r15d
xorl %r12d, %r12d
movl %ebp, %edi
movl %r14d, %esi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x2403
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebx, %r8d
callq 0x1fff
incl %r12d
cmpl $0x5, %r12d
jne 0x24e0
incl %ebx
cmpl $0x3e8, %ebx            # imm = 0x3E8
jne 0x24c6
jmp 0x25c8
xorl %r14d, %r14d
movl %r14d, %edi
callq 0x12d0
movl %eax, %ebp
movq %r14, 0x10(%rsp)
leal (,%r14,4), %eax
leal (%rax,%rax,2), %eax
movq %rax, 0x18(%rsp)
movl %ebx, 0xc(%rsp)
movl %ebx, %r14d
xorl %ebx, %ebx
movl %ebx, %edi
callq 0x12d0
movl %eax, %r15d
movq 0x18(%rsp), %rax
movq %rbx, 0x20(%rsp)
leal (%rbx,%rax), %r12d
xorl %r13d, %r13d
movl %ebp, %edi
movl %r15d, %esi
movl %r13d, %edx
movl %r12d, %ecx
callq 0x2403
xorl %ebx, %ebx
movl %ebx, %edi
callq 0x12d0
leal (%r14,%rbx), %r8d
movl %ebp, %edi
movl %r15d, %esi
movl %eax, %edx
movl %r13d, %ecx
callq 0x1fff
incl %ebx
cmpl $0xc, %ebx
jne 0x2572
incl %r13d
cmpl $0x5, %r13d
jne 0x2560
movq 0x20(%rsp), %rbx
incl %ebx
addl $0xc, %r14d
cmpl $0xc, %ebx
jne 0x2545
movq 0x10(%rsp), %r14
incl %r14d
movl 0xc(%rsp), %ebx
addl $0x90, %ebx
cmpl $0xc, %r14d
jne 0x251d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: special_sf128
F_UINT special_sf(int i)
{
    switch(i) {
    case 0: /* zero */
    case 1:
        return pack_sf(i & 1, 0, 0);
    case 2: /* infinity */
    case 3:
        return pack_sf(i & 1, EXP_MASK, 0);
    case 4: /* 1.0 */
    case 5:
        return pack_sf(i & 1, EXP_MASK / 2, 0);
    case 6: /* QNAN */
    case 7:
        return pack_sf(i & 1, EXP_MASK, QNAN_MASK);
    case 8: /* SNAN */
    case 9:
        return pack_sf(i & 1, EXP_MASK, 1);
    case 10: /* subnormal */
    case 11:
        return pack_sf(i & 1, 0, 1);
    default:
        abort();
    }
}

// Assembly:
cmpl $0xb, %edi
ja 0x3b96
movl %edi, %eax
leaq 0x1253e(%rip), %rcx     # 0x16070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlq $0x3f, %rdi
jmp 0x3b85
shlq $0x3f, %rdi
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
orq %rax, %rdi
jmp 0x3b8d
shlq $0x3f, %rdi
movabsq $0x3fff000000000000, %rax # imm = 0x3FFF000000000000
jmp 0x3b82
shlq $0x3f, %rdi
movabsq $0x7fff800000000000, %rax # imm = 0x7FFF800000000000
jmp 0x3b82
shlq $0x3f, %rdi
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
orq %rax, %rdi
xorl %eax, %eax
jmp 0x3b92
shlq $0x3f, %rdi
movl $0x1, %eax
movq %rdi, %rdx
retq
pushq %rax
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: print_sf128
static void print_sf(F_UINT a)
{
    uint32_t a_sign, a_exp;
    F_UINT a_mant;
    a_sign = a >> (F_SIZE - 1);
    a_exp = (a >> MANT_SIZE) & EXP_MASK;
    a_mant = a & MANT_MASK;
    printf("%u %0*x ",
           a_sign,
           (EXP_SIZE + 3) / 4, a_exp);
#if F_SIZE == 32
    printf("%0*x", (MANT_SIZE + 3) / 4, a_mant);
#elif F_SIZE == 64
    printf("%0*" PRIx64 , (MANT_SIZE + 3) / 4, a_mant);
#elif F_SIZE == 128
    printf("%0*" PRIx64 "%016" PRIx64, 
           ((MANT_SIZE - 64) + 3) / 4, (uint64_t)(a_mant >> 64), (uint64_t)a_mant);
#else
#error unsupported F_SIZE
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rcx
movabsq $0xffffffffffff, %r14   # imm = 0xFFFFFFFFFFFF
andq %rsi, %r14
shrq $0x3f, %rsi
shrq $0x30, %rcx
andl $0x7fff, %ecx           # imm = 0x7FFF
leaq 0x125c3(%rip), %rdi     # 0x164b2
movl $0x4, %edx
xorl %eax, %eax
callq 0x1070
leaq 0x125d1(%rip), %rdi     # 0x164d3
movl $0xc, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfptest.c
// Function: main
int main(int argc, char **argv)
{
    int seed;

    seed = 1;
    if (argc >= 2)
        seed = atoi(argv[1]);
    srandom(seed);

    printf("Starting softfptest (stop with Ctrl-C)\n");
    test_float32(0);
    test_float64(0);
#ifdef HAVE_INT128
    test_float128(0);
#endif
    for(;;) {
        test_float32(1);
        test_float64(1);
#ifdef HAVE_INT128
        test_float128(1);
#endif
    }
    return 0;
}

// Assembly:
pushq %rax
movl %edi, %eax
movl $0x1, %edi
cmpl $0x2, %eax
jl 0x4e67
movq 0x8(%rsi), %rdi
callq 0x10a0
movl %eax, %edi
callq 0x1050
leaq 0x1166c(%rip), %rdi     # 0x164df
callq 0x1060
xorl %edi, %edi
callq 0x24b2
xorl %edi, %edi
callq 0x3946
xorl %edi, %edi
callq 0x4d4d
movl $0x1, %edi
callq 0x24b2
movl $0x1, %edi
callq 0x3946
movl $0x1, %edi
callq 0x4d4d
jmp 0x4e8d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: normalize_sf128
static F_UINT normalize_sf(uint32_t a_sign, int a_exp, F_UINT a_mant,
                           RoundingModeEnum rm, uint32_t *pfflags)
{
    int shift;
    shift = clz(a_mant) - (F_SIZE - 1 - IMANT_SIZE);
    assert(shift >= 0);
    a_exp -= shift;
    a_mant <<= shift;
    return round_pack_sf(a_sign, a_exp, a_mant, rm, pfflags);
}

// Assembly:
movq %rcx, %rax
movq %rdx, %rcx
orq %rax, %rcx
je 0x7b0a
testq %rax, %rax
je 0x7b11
bsrq %rax, %rcx
xorq $0x3f, %rcx
jne 0x7b1b
pushq %rax
leaq 0xea14(%rip), %rdi      # 0x16506
leaq 0xea18(%rip), %rsi      # 0x16511
leaq 0xeb77(%rip), %rcx      # 0x16677
movl $0xb7, %edx
callq 0x1080
movl $0x80, %ecx
jmp 0x7b1b
bsrq %rdx, %rcx
xorl $0x3f, %ecx
orl $0x40, %ecx
decl %ecx
subl %ecx, %esi
shldq %cl, %rdx, %rax
shlq %cl, %rdx
xorl %r10d, %r10d
testb $0x40, %cl
cmovneq %rdx, %rax
cmoveq %rdx, %r10
movq %r10, %rdx
movq %rax, %rcx
jmp 0x99b4
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: min_sf32
F_UINT glue(min_sf, F_SIZE)(F_UINT a, F_UINT b, uint32_t *pfflags)
{
    uint32_t a_sign, b_sign;

    if (isnan_sf(a) || isnan_sf(b)) {
        if (issignan_sf(a) || issignan_sf(b)) {
            *pfflags |= FFLAG_INVALID_OP;
            return F_QNAN;
        } else if (isnan_sf(a)) {
            if (isnan_sf(b)) 
                return F_QNAN;
            else
                return b;
        } else {
            return a;
        }
    }
    a_sign = a >> (F_SIZE - 1);
    b_sign = b >> (F_SIZE - 1);

    if (a_sign != b_sign) {
        if (a_sign)
            return a;
        else
            return b;
    } else {
        if ((a < b) ^ a_sign)
            return a;
        else
            return b;
    }
}

// Assembly:
movl %edi, %eax
movl %edi, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
sete %dil
testl $0x7fffff, %eax         # imm = 0x7FFFFF
setne %cl
andb %dil, %cl
jne 0x58f3
movl %esi, %edi
notl %edi
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %dil
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %r8b
orb %dil, %r8b
je 0x58f3
movl %esi, %ecx
xorl %eax, %ecx
js 0x5960
testl %eax, %eax
sets %cl
cmpl %esi, %eax
setae %dl
xorb %cl, %dl
jmp 0x595c
testl $0x7fffff, %eax         # imm = 0x7FFFFF
setne %dil
movl %eax, %r8d
andl $0x7fc00000, %r8d       # imm = 0x7FC00000
cmpl $0x7f800000, %r8d       # imm = 0x7F800000
sete %r8b
testb %dil, %r8b
jne 0x5937
movl %esi, %edi
andl $0x7fc00000, %edi       # imm = 0x7FC00000
cmpl $0x7f800000, %edi       # imm = 0x7F800000
setne %dil
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %r8b
orb %dil, %r8b
jne 0x5940
orb $0x10, (%rdx)
movl $0x7fc00000, %eax       # imm = 0x7FC00000
retq
testb %cl, %cl
je 0x595f
testl $0x7fffff, %esi         # imm = 0x7FFFFF
movl %esi, %ecx
movl $0x7fc00000, %eax       # imm = 0x7FC00000
cmovel %esi, %eax
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
cmovnel %esi, %eax
retq
testl %eax, %eax
cmovnsl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: eq_quiet_sf32
BOOL isnan_sf(F_UINT a)
{
    uint32_t a_exp;
    F_UINT a_mant;
    a_exp = (a >> MANT_SIZE) & EXP_MASK;
    a_mant = a & MANT_MASK;
    return (a_exp == EXP_MASK && a_mant != 0);
}

// Assembly:
movl %edi, %eax
notl %eax
testl $0x7f800000, %eax       # imm = 0x7F800000
sete %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
setne %cl
testb %cl, %al
jne 0x5a6e
movl %esi, %eax
notl %eax
testl $0x7f800000, %eax       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
je 0x5a6e
movl %esi, %eax
orl %edi, %eax
testl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x5ab1
xorl %eax, %eax
cmpl %esi, %edi
sete %al
retq
testl $0x7fffff, %edi         # imm = 0x7FFFFF
setne %al
andl $0x7fc00000, %edi       # imm = 0x7FC00000
cmpl $0x7f800000, %edi       # imm = 0x7F800000
sete %cl
testb %al, %cl
jne 0x5aab
movl %esi, %eax
andl $0x7fc00000, %eax       # imm = 0x7FC00000
cmpl $0x7f800000, %eax       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %sil
xorl %eax, %eax
orb %cl, %sil
je 0x5aab
retq
orb $0x10, (%rdx)
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template_icvt.h
// Function: internal_cvt_i128_sf32
static F_UINT glue(glue(glue(internal_cvt_i, ICVT_SIZE), _sf), F_SIZE)(ICVT_INT a, 
                                                                       RoundingModeEnum rm,
                                                                       uint32_t *pfflags,
                                                                       BOOL is_unsigned)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;
    ICVT_UINT r, mask;
    int l;

    if (!is_unsigned && a < 0) {
        a_sign = 1;
        r = -(ICVT_UINT)a;
    } else {
        a_sign = 0;
        r = a;
    }
    a_exp = (EXP_MASK / 2) + F_SIZE - 2;
    /* need to reduce range before generic float normalization */
    l = ICVT_SIZE - glue(clz, ICVT_SIZE)(r) - (F_SIZE - 1);
    if (l > 0) {
        mask = r & (((ICVT_UINT)1 << l) - 1);
        r = (r >> l) | ((r & mask) != 0);
        a_exp += l;
    }
    a_mant = r;
    return normalize_sf(a_sign, a_exp, a_mant, rm, pfflags);
}

// Assembly:
movq %rcx, %r9
testl %r8d, %r8d
sete %al
testq %rsi, %rsi
sets %r8b
andb %al, %r8b
xorl %ecx, %ecx
movq %rdi, %r10
negq %r10
movl $0x0, %r11d
sbbq %rsi, %r11
testb %r8b, %r8b
cmoveq %rsi, %r11
cmoveq %rdi, %r10
movl %edx, %eax
movl $0x9d, %esi
movq %r10, %rdx
orq %r11, %rdx
je 0x618e
testq %r11, %r11
je 0x6121
bsrq %r11, %rdx
xorl $0x3f, %edx
jmp 0x6133
bsrq %r10, %rdx
xorl $0x3f, %edx
orl $0x40, %edx
movl %r10d, %ecx
cmpl $0x60, %edx
ja 0x618e
pushq %r15
pushq %r14
pushq %rbx
movb $0x61, %cl
subb %dl, %cl
movq $-0x1, %rsi
shlq %cl, %rsi
movq %r10, %rdi
shrdq %cl, %r11, %rdi
movq %r11, %rbx
shrq %cl, %rbx
movq $-0x1, %r14
xorl %r15d, %r15d
testb $0x40, %cl
cmovneq %rsi, %r14
cmoveq %rsi, %r15
notq %r15
notq %r14
cmoveq %rdi, %rbx
andq %r11, %r14
andq %r10, %r15
xorl %ecx, %ecx
orq %r14, %r15
setne %cl
orl %ebx, %ecx
movl $0xfe, %esi
subl %edx, %esi
popq %rbx
popq %r14
popq %r15
movzbl %r8b, %edi
movl %ecx, %edx
movl %eax, %ecx
movq %r9, %r8
jmp 0x5020
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: eq_quiet_sf64
int glue(eq_quiet_sf, F_SIZE)(F_UINT a, F_UINT b, uint32_t *pfflags)
{
    if (isnan_sf(a) || isnan_sf(b)) {
        if (issignan_sf(a) || issignan_sf(b)) {
            *pfflags |= FFLAG_INVALID_OP;
        }
        return 0;
    }

    if ((F_UINT)((a | b) << 1) == 0)
        return 1; /* zero case */
    return (a == b);
}

// Assembly:
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
movq %rdi, %r8
notq %r8
testq %rcx, %r8
sete %r8b
movq %rdi, %r9
shlq $0xc, %r9
setne %r9b
testb %r9b, %r8b
jne 0x6ffa
movq %rsi, %r8
notq %r8
testq %r8, %rcx
setne %r8b
testq %rax, %rsi
sete %r9b
orb %r8b, %r9b
je 0x6ffa
movq %rsi, %rax
orq %rdi, %rax
shlq %rax
testq %rax, %rax
je 0x7038
xorl %eax, %eax
cmpq %rsi, %rdi
sete %al
retq
testq %rax, %rdi
setne %r9b
movabsq $0x7ff8000000000000, %r8 # imm = 0x7FF8000000000000
andq %r8, %rdi
cmpq %rcx, %rdi
sete %dil
testb %r9b, %dil
jne 0x7032
andq %rsi, %r8
cmpq %rcx, %r8
setne %cl
testq %rax, %rsi
sete %sil
xorl %eax, %eax
orb %cl, %sil
je 0x7032
retq
orb $0x10, (%rdx)
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: le_sf64
int glue(le_sf, F_SIZE)(F_UINT a, F_UINT b, uint32_t *pfflags)
{
    uint32_t a_sign, b_sign;

    if (isnan_sf(a) || isnan_sf(b)) {
        *pfflags |= FFLAG_INVALID_OP;
        return 0;
    }

    a_sign = a >> (F_SIZE - 1);
    b_sign = b >> (F_SIZE - 1);
    if (a_sign != b_sign) {
        return (a_sign || ((F_UINT)((a | b) << 1) == 0));
    } else {
        if (a_sign) {
            return (a >= b);
        } else {
            return (a <= b);
        }
    }
}

// Assembly:
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rdi, %rcx
notq %rcx
testq %rax, %rcx
sete %cl
movq %rdi, %r8
shlq $0xc, %r8
setne %r8b
testb %r8b, %cl
jne 0x7099
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq %rsi, %r8
notq %r8
testq %r8, %rax
setne %al
testq %rcx, %rsi
sete %cl
orb %al, %cl
je 0x7099
movq %rsi, %rax
xorq %rdi, %rax
js 0x70a2
testq %rdi, %rdi
js 0x70b7
cmpq %rsi, %rdi
setbe %al
jmp 0x709e
orb $0x10, (%rdx)
xorl %eax, %eax
movzbl %al, %eax
retq
testq %rdi, %rdi
sets %cl
btrq $0x3f, %rsi
orq %rdi, %rsi
sete %al
orb %cl, %al
jmp 0x709e
cmpq %rsi, %rdi
setae %al
jmp 0x709e
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: cvt_sf64_sf32
uint32_t glue(glue(cvt_sf, F_SIZE), _sf32)(F_UINT a, RoundingModeEnum rm,
                                           uint32_t *pfflags)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;

    a_mant = unpack_sf(&a_sign, &a_exp, a);
    if (a_exp == EXP_MASK) {
        if (a_mant != 0) {
            /* NaN */
            if (issignan_sf(a)) {
                *pfflags |= FFLAG_INVALID_OP;
            }
            return F_QNAN32;
        } else {
            /* infinity */
            return pack_sf32(a_sign, 0xff, 0);
        }
    }
    if (a_exp == 0) {
        if (a_mant == 0)
            return pack_sf32(a_sign, 0, 0); /* zero */
        normalize_subnormal_sf(&a_exp, a_mant);
    } else {
        a_mant |= (F_UINT)1 << MANT_SIZE;
    }
    /* convert the exponent value */
    a_exp = a_exp - (EXP_MASK / 2) + 0x7f;
    /* shift the mantissa */
    a_mant = rshift_rnd(a_mant, MANT_SIZE - (32 - 2));
    return normalize_sf32(a_sign, a_exp, a_mant, rm, pfflags);
}

// Assembly:
movq %rdx, %r8
movl %esi, %ecx
movq %rdi, %rax
movabsq $0xfffffffffffff, %rdx  # imm = 0xFFFFFFFFFFFFF
shrq $0x3f, %rdi
movq %rax, %rsi
shrq $0x34, %rsi
movq %rax, %r9
andq %rdx, %r9
andl $0x7ff, %esi            # imm = 0x7FF
je 0x72ae
cmpl $0x7ff, %esi            # imm = 0x7FF
jne 0x72bf
testq %r9, %r9
je 0x72e5
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
andq %rcx, %rax
movl $0x7fc00000, %edi       # imm = 0x7FC00000
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0x72f3
orb $0x10, (%r8)
jmp 0x72f3
testq %r9, %r9
je 0x72f0
bsrq %r9, %rsi
xorl $-0x40, %esi
addl $0xd, %esi
jmp 0x72c5
addq %rdx, %r9
incq %r9
addl $0xfffffc80, %esi       # imm = 0xFFFFFC80
movq %r9, %rax
shrq $0x16, %rax
xorl %edx, %edx
testl $0x3fffff, %r9d         # imm = 0x3FFFFF
setne %dl
orl %eax, %edx
jmp 0x5020
shll $0x1f, %edi
orl $0x7f800000, %edi       # imm = 0x7F800000
jmp 0x72f3
shll $0x1f, %edi
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: rshift_rnd128
static F_UINT rshift_rnd(F_UINT a, int d)
{
    F_UINT mask;
    if (d != 0) {
        if (d >= F_SIZE) {
            a = (a != 0);
        } else {
            mask = ((F_UINT)1 << d) - 1;
            a = (a >> d) | ((a & mask) != 0);
        }
    }
    return a;
}

// Assembly:
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rax
testl %ecx, %ecx
je 0x7acf
cmpl $0x80, %ecx
jl 0x7a81
xorl %ecx, %ecx
orq %rdx, %rax
setne %cl
xorl %edx, %edx
movq %rcx, %rax
retq
movq $-0x1, %rdi
shlq %cl, %rdi
movq %rax, %rsi
shrdq %cl, %rdx, %rsi
movq $-0x1, %r9
movq %rdx, %r8
shrq %cl, %r8
xorl %r10d, %r10d
testb $0x40, %cl
cmovneq %rdi, %r9
cmovneq %r10, %rdi
notq %rdi
cmovneq %r8, %rsi
cmovneq %r10, %r8
notq %r9
andq %rdx, %r9
andq %rax, %rdi
xorl %eax, %eax
orq %r9, %rdi
setne %al
orq %rsi, %rax
movq %r8, %rdx
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: divrem_u128
static F_UINT divrem_u(F_UINT *pr, F_UINT a1, F_UINT a0, F_UINT b)
{
    int i, qb, ab;

    assert(a1 < b);
    for(i = 0; i < F_SIZE; i++) {
        ab = a1 >> (F_SIZE - 1);
        a1 = (a1 << 1) | (a0 >> (F_SIZE - 1));
        if (ab || a1 >= b) {
            a1 -= b;
            qb = 1;
        } else {
            qb = 0;
        }
        a0 = (a0 << 1) | qb;
    }
    *pr = a1;
    return a0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rcx, %rsi
movq %rdx, %rax
sbbq %r8, %rax
jae 0x8835
movl $0x80, %r10d
xorl %eax, %eax
xorl %r9d, %r9d
movq %rdx, %r11
shldq $0x1, %rsi, %rdx
shldq $0x1, %r9, %rsi
testq %r11, %r11
sets %bl
cmpq %rcx, %rsi
movq %rdx, %r11
sbbq %r8, %r11
setae %r11b
orb %bl, %r11b
movq %r8, %rbx
movq %rcx, %r14
jne 0x880b
xorl %ebx, %ebx
xorl %r14d, %r14d
subq %r14, %rsi
sbbq %rbx, %rdx
shldq $0x1, %rax, %r9
movzbl %r11b, %r11d
leaq (%r11,%rax,2), %rax
decl %r10d
jne 0x87db
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r9, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xdeeb(%rip), %rdi      # 0x16727
leaq 0xdcce(%rip), %rsi      # 0x16511
leaq 0xdee4(%rip), %rcx      # 0x1672e
movl $0x23b, %edx            # imm = 0x23B
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: cvt_sf128_sf64
uint64_t glue(glue(cvt_sf, F_SIZE), _sf64)(F_UINT a, RoundingModeEnum rm,
                                               uint32_t *pfflags)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;

    a_mant = unpack_sf(&a_sign, &a_exp, a);
    if (a_exp == EXP_MASK) {
        if (a_mant != 0) {
            /* NaN */
            if (issignan_sf(a)) {
                *pfflags |= FFLAG_INVALID_OP;
            }
            return F_QNAN64;
        } else {
            /* infinity */
            return pack_sf64(a_sign, 0x7ff, 0);
        }
    }
    if (a_exp == 0) {
        if (a_mant == 0)
            return pack_sf64(a_sign, 0, 0); /* zero */
        normalize_subnormal_sf(&a_exp, a_mant);
    } else {
        a_mant |= (F_UINT)1 << MANT_SIZE;
    }
    /* convert the exponent value */
    a_exp = a_exp - (EXP_MASK / 2) + 0x3ff;
    /* shift the mantissa */
    a_mant = rshift_rnd(a_mant, MANT_SIZE - (64 - 2));
    return normalize_sf64(a_sign, a_exp, a_mant, rm, pfflags);
}

// Assembly:
movq %rcx, %r8
movl %edx, %ecx
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
movq %rsi, %rax
shrq $0x30, %rax
movq %rsi, %r9
andq %rdx, %r9
andl $0x7fff, %eax           # imm = 0x7FFF
je 0x9152
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x917a
orq %rdi, %r9
je 0x91a3
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movabsq $0x7fff800000000000, %rcx # imm = 0x7FFF800000000000
andq %rsi, %rcx
movabsq $0x7fff000000000000, %r9 # imm = 0x7FFF000000000000
cmpq %r9, %rcx
jne 0x91bd
andq %rdx, %rsi
orq %rsi, %rdi
je 0x91bd
orb $0x10, (%r8)
retq
movq %rdi, %rax
orq %r9, %rax
je 0x91be
bsrq %r9, %rax
xorl $0x3f, %eax
bsrq %rdi, %rdx
xorl $0x3f, %edx
orl $0x40, %edx
testq %r9, %r9
cmovnel %eax, %edx
movl $0x10, %eax
subl %edx, %eax
jmp 0x9180
addq %rdx, %r9
incq %r9
shrq $0x3f, %rsi
addl $0xffffc400, %eax       # imm = 0xFFFFC400
shldq $0xe, %rdi, %r9
xorl %edx, %edx
shlq $0xe, %rdi
setne %dl
orq %r9, %rdx
movl %esi, %edi
movl %eax, %esi
jmp 0x6347
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %rsi
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
orq %rsi, %rax
retq
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %rsi
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_minnummag
float32 float32_squash_input_denormal(float32 a, float_status *status)
{
    if (status->flush_inputs_to_zero) {
        if (extractFloat32Exp(a) == 0 && extractFloat32Frac(a) != 0) {
            float_raise(float_flag_input_denormal, status);
            return make_float32(float32_val(a) & 0x80000000);
        }
    }
    return a;
}

// Assembly:
cmpb $0x0, 0x5(%rdx)
je 0x14ead
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0x14e8d
orb $0x40, 0x2(%rdx)
andl $0x80000000, %edi       # imm = 0x80000000
testl $0x7f800000, %esi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0x14ead
orb $0x40, 0x2(%rdx)
andl $0x80000000, %esi       # imm = 0x80000000
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %edi, %ecx
andl %eax, %ecx
andl %esi, %eax
cmpl $0x7f800000, %ecx       # imm = 0x7F800000
jbe 0x14eda
cmpl $0x7f800001, %eax       # imm = 0x7F800001
setb %al
leal (%rdi,%rdi), %ecx
cmpl $0xff800000, %ecx       # imm = 0xFF800000
setae %cl
testb %al, %cl
je 0x14f15
jmp 0x14f24
cmpl $0x7f800001, %eax       # imm = 0x7F800001
jae 0x14efc
cmpl %eax, %ecx
jne 0x14f1a
movl %esi, %eax
xorl %edi, %eax
js 0x14f1f
testl %edi, %edi
sets %al
cmpl %esi, %edi
setae %cl
xorb %al, %cl
cmovnel %esi, %edi
jmp 0x14f26
cmpl $0x7f800001, %ecx       # imm = 0x7F800001
setb %al
leal (%rsi,%rsi), %ecx
cmpl $0xff800000, %ecx       # imm = 0xFF800000
setae %cl
testb %cl, %al
jne 0x14f26
jmp 0xaf64
cmovbl %edi, %esi
jmp 0x14f24
testl %edi, %edi
cmovsl %edi, %esi
movl %esi, %edi
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_squash_input_denormal
float64 float64_squash_input_denormal(float64 a, float_status *status)
{
    if (status->flush_inputs_to_zero) {
        if (extractFloat64Exp(a) == 0 && extractFloat64Frac(a) != 0) {
            float_raise(float_flag_input_denormal, status);
            return make_float64(float64_val(a) & (1ULL << 63));
        }
    }
    return a;
}

// Assembly:
movq %rdi, %rax
cmpb $0x0, 0x5(%rsi)
je 0x9db5
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testq %rcx, %rax
setne %cl
movq %rax, %rdx
shlq $0xc, %rdx
sete %dl
orb %cl, %dl
jne 0x9db5
orb $0x40, 0x2(%rsi)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: int32_to_float32
float32 int32_to_float32(int32_t a, float_status *status)
{
    flag zSign;

    if ( a == 0 ) return float32_zero;
    if ( a == (int32_t) 0x80000000 ) return packFloat32( 1, 0x9E, 0 );
    zSign = ( a < 0 );
    return normalizeRoundAndPackFloat32(zSign, 0x9C, zSign ? -a : a, status);
}

// Assembly:
testl %edi, %edi
je 0x9dc5
movl %edi, %ecx
negl %ecx
jno 0x9dc8
movl $0xcf000000, %edi       # imm = 0xCF000000
movl %edi, %eax
retq
movq %rsi, %rax
movl %edi, %r8d
shrl $0x1f, %r8d
movl %edi, %edx
negl %edx
cmovsl %edi, %edx
testl %edx, %edx
je 0x9de5
bsrl %edx, %ecx
xorl $0x1f, %ecx
jmp 0x9dea
movl $0x20, %ecx
decb %cl
movzbl %cl, %ecx
movl $0x9c, %esi
subq %rcx, %rsi
shll %cl, %edx
movzbl %r8b, %edi
movq %rax, %rcx
jmp 0x9f46
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: int32_to_float64
float64 int32_to_float64(int32_t a, float_status *status)
{
    flag zSign;
    uint32 absA;
    int8 shiftCount;
    uint64_t zSig;

    if ( a == 0 ) return float64_zero;
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros32( absA ) + 21;
    zSig = absA;
    return packFloat64( zSign, 0x432 - shiftCount, zSig<<shiftCount );

}

// Assembly:
testl %edi, %edi
je 0x9e3d
movl %edi, %edx
shrl $0x1f, %edx
movl %edi, %esi
negl %esi
cmovsl %edi, %esi
bsrl %esi, %ecx
xorl $0x1f, %ecx
addl $0x15, %ecx
shlq %cl, %rsi
shlq $0x3f, %rdx
movabsq $0x4320000000000000, %rax # imm = 0x4320000000000000
orq %rdx, %rax
shlq $0x34, %rcx
subq %rcx, %rax
addq %rsi, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: int32_to_floatx80
floatx80 int32_to_floatx80(int32_t a, float_status *status)
{
    flag zSign;
    uint32 absA;
    int8 shiftCount;
    uint64_t zSig;

    if ( a == 0 ) return packFloatx80( 0, 0, 0 );
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros32( absA ) + 32;
    zSig = absA;
    return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );

}

// Assembly:
testl %edi, %edi
je 0x9e6d
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
orb $0x20, %cl
movzbl %cl, %ecx
shlq %cl, %rax
shrl $0x10, %edi
andl $0x8000, %edi           # imm = 0x8000
subl %ecx, %edi
addl $0x403e, %edi           # imm = 0x403E
jmp 0x9e71
xorl %eax, %eax
xorl %edi, %edi
movl %edi, %edx
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: int32_to_float128
float128 int32_to_float128(int32_t a, float_status *status)
{
    flag zSign;
    uint32 absA;
    int8 shiftCount;
    uint64_t zSig0;

    if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros32( absA ) + 17;
    zSig0 = absA;
    return packFloat128( zSign, 0x402E - shiftCount, zSig0<<shiftCount, 0 );

}

// Assembly:
testl %edi, %edi
je 0x9eae
movl %edi, %eax
shrl $0x1f, %eax
movl %edi, %edx
negl %edx
cmovsl %edi, %edx
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $0x11, %ecx
shlq %cl, %rdx
shlq $0x3f, %rax
addq %rdx, %rax
shlq $0x30, %rcx
subq %rcx, %rax
movabsq $0x402e000000000000, %rdx # imm = 0x402E000000000000
addq %rax, %rdx
xorl %eax, %eax
retq
xorl %eax, %eax
xorl %edx, %edx
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: int64_to_float32
float32 int64_to_float32(int64_t a, float_status *status)
{
    flag zSign;
    uint64 absA;
    int8 shiftCount;

    if ( a == 0 ) return float32_zero;
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros64( absA ) - 40;
    if ( 0 <= shiftCount ) {
        return packFloat32( zSign, 0x95 - shiftCount, absA<<shiftCount );
    }
    else {
        shiftCount += 7;
        if ( shiftCount < 0 ) {
            shift64RightJamming( absA, - shiftCount, &absA );
        }
        else {
            absA <<= shiftCount;
        }
        return roundAndPackFloat32(zSign, 0x9C - shiftCount, absA, status);
    }

}

// Assembly:
testq %rdi, %rdi
je 0x9ef5
movq %rsi, %r8
movq %rdi, %rax
shrq $0x3f, %rax
movq %rdi, %rsi
negq %rsi
cmovsq %rdi, %rsi
bsrq %rsi, %rcx
xorl $0x3f, %ecx
cmpq $0xffffff, %rsi         # imm = 0xFFFFFF
ja 0x9ef8
addb $-0x28, %cl
movzbl %cl, %ecx
shlq %cl, %rsi
shll $0x1f, %eax
orl $0x4a800000, %eax       # imm = 0x4A800000
shll $0x17, %ecx
subl %ecx, %eax
addl %esi, %eax
retq
xorl %eax, %eax
retq
addb $-0x21, %cl
movsbl %cl, %edi
movq %rsi, %rdx
shrq $0x1f, %rdx
je 0x9f31
testb %cl, %cl
je 0x9f34
movl %edi, %ecx
negl %ecx
movl $0x1, %edx
cmpl $0x3f, %ecx
ja 0x9f37
movq %rsi, %r9
shrq %cl, %r9
negb %cl
shlq %cl, %rsi
xorl %edx, %edx
testq %rsi, %rsi
setne %dl
orq %r9, %rdx
jmp 0x9f37
shlq %cl, %rsi
movq %rsi, %rdx
movl $0x9c, %esi
subl %edi, %esi
movzbl %al, %edi
movq %r8, %rcx
jmp 0x9f46
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: int64_to_float64
float64 int64_to_float64(int64_t a, float_status *status)
{
    flag zSign;

    if ( a == 0 ) return float64_zero;
    if ( a == (int64_t) LIT64( 0x8000000000000000 ) ) {
        return packFloat64( 1, 0x43E, 0 );
    }
    zSign = ( a < 0 );
    return normalizeRoundAndPackFloat64(zSign, 0x43C, zSign ? -a : a, status);
}

// Assembly:
testq %rdi, %rdi
je 0xa0a1
movq %rdi, %rcx
negq %rcx
jno 0xa0a5
movabsq $-0x3c20000000000000, %rdi # imm = 0xC3E0000000000000
movq %rdi, %rax
retq
movq %rsi, %rax
movq %rdi, %r8
shrq $0x3f, %r8
movq %rdi, %rdx
negq %rdx
cmovsq %rdi, %rdx
testq %rdx, %rdx
je 0xa0c8
bsrq %rdx, %rcx
xorq $0x3f, %rcx
jmp 0xa0cd
movl $0x40, %ecx
movl $0x43d, %esi            # imm = 0x43D
subq %rcx, %rsi
decb %cl
shlq %cl, %rdx
movzbl %r8b, %edi
movq %rax, %rcx
jmp 0xa25f
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: int64_to_floatx80
floatx80 int64_to_floatx80(int64_t a, float_status *status)
{
    flag zSign;
    uint64 absA;
    int8 shiftCount;

    if ( a == 0 ) return packFloatx80( 0, 0, 0 );
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros64( absA );
    return packFloatx80( zSign, 0x403E - shiftCount, absA<<shiftCount );

}

// Assembly:
testq %rdi, %rdi
je 0xa114
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
bsrq %rax, %rcx
xorq $0x3f, %rcx
shlq %cl, %rax
shrq $0x30, %rdi
andl $0x8000, %edi           # imm = 0x8000
subl %ecx, %edi
addl $0x403e, %edi           # imm = 0x403E
jmp 0xa118
xorl %eax, %eax
xorl %edi, %edi
movl %edi, %edx
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: int64_to_float128
float128 int64_to_float128(int64_t a, float_status *status)
{
    flag zSign;
    uint64 absA;
    int8 shiftCount;
    int32 zExp;
    uint64_t zSig0, zSig1;

    if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros64( absA ) + 49;
    zExp = 0x406E - shiftCount;
    if ( 64 <= shiftCount ) {
        zSig1 = 0;
        zSig0 = absA;
        shiftCount -= 64;
    }
    else {
        zSig1 = absA;
        zSig0 = 0;
    }
    shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
    return packFloat128( zSign, zExp, zSig0, zSig1 );

}

// Assembly:
testq %rdi, %rdi
je 0xa192
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
andq %rdi, %rdx
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
bsrq %rax, %rcx
xorl $0x3f, %ecx
leal 0x31(%rcx), %edi
movq %rax, %r8
shrq $0x31, %r8
addb $-0xf, %cl
xorl %esi, %esi
testq %r8, %r8
cmoveq %rax, %rsi
movzbl %dil, %edi
cmovneq %rax, %r8
movzbl %cl, %ecx
cmovnel %edi, %ecx
movq %r8, %rax
shlq %cl, %rax
testb %cl, %cl
je 0xa17a
movzbl %cl, %ecx
shlq %cl, %rsi
negb %cl
shrq %cl, %r8
orq %r8, %rsi
movabsq $0x406e000000000000, %rcx # imm = 0x406E000000000000
orq %rcx, %rdx
shlq $0x30, %rdi
subq %rdi, %rdx
addq %rsi, %rdx
retq
xorl %eax, %eax
xorl %edx, %edx
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: uint64_to_float32
float32 uint64_to_float32(uint64_t a, float_status *status)
{
    int shiftcount;

    if (a == 0) {
        return float32_zero;
    }

    /* Determine (left) shift needed to put first set bit into bit posn 23
     * (since packFloat32() expects the binary point between bits 23 and 22);
     * this is the fast case for smallish numbers.
     */
    shiftcount = countLeadingZeros64(a) - 40;
    if (shiftcount >= 0) {
        return packFloat32(0, 0x95 - shiftcount, a << shiftcount);
    }
    /* Otherwise we need to do a round-and-pack. roundAndPackFloat32()
     * expects the binary point between bits 30 and 29, hence the + 7.
     */
    shiftcount += 7;
    if (shiftcount < 0) {
        shift64RightJamming(a, -shiftcount, &a);
    } else {
        a <<= shiftcount;
    }

    return roundAndPackFloat32(0, 0x9c - shiftcount, a, status);
}

// Assembly:
testq %rdi, %rdi
je 0xa1c7
bsrq %rdi, %r8
xorq $0x3f, %r8
cmpq $0xffffff, %rdi         # imm = 0xFFFFFF
ja 0xa1cc
movl $0xffffffd8, %ecx       # imm = 0xFFFFFFD8
addl %r8d, %ecx
shlq %cl, %rdi
shll $0x17, %r8d
subl %r8d, %edi
addl $0x5e800000, %edi       # imm = 0x5E800000
jmp 0xa1c9
xorl %edi, %edi
movl %edi, %eax
retq
movq %rsi, %rax
movq %rdi, %rcx
shrq $0x1f, %rcx
je 0xa208
movl $0x21, %ecx
subl %r8d, %ecx
je 0xa20f
movl $0x1, %edx
cmpl $0x3f, %ecx
ja 0xa212
leaq 0x1f(%r8), %rdx
movq %rdi, %rsi
shrq %cl, %rsi
movl %edx, %ecx
shlq %cl, %rdi
xorl %edx, %edx
testq %rdi, %rdi
setne %dl
orq %rsi, %rdx
jmp 0xa212
leal -0x21(%r8), %ecx
shlq %cl, %rdi
movq %rdi, %rdx
movl $0xbd, %esi
subq %r8, %rsi
xorl %edi, %edi
movq %rax, %rcx
jmp 0x9f46