LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: rrandom_u32
F_UINT rrandom_u(int len)
{
    int bit, pos, n, end;
    F_UINT a;
    
    bit = random() & 1;
    pos = 0;
    a = 0;
    for(;;) {
        n = (random() % len) + 1;
        end = pos + n;
        if (end > len)
            end = len;
        if (bit) {
            n = end - pos;
            if (n == F_SIZE)
                a = (F_UINT)(-1);
            else
                a |= (((F_UINT)1 << n) - 1) << pos;
        }
        if (end >= len)
            break;
        pos = end;
        bit ^= 1;
    }
    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
callq 0x1090
movq %rax, %r14
andl $0x1, %r14d
movslq %ebx, %r12
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ebp
movl %edx, %r15d
callq 0x1090
cqto
idivq %r12
leal (%r15,%rdx), %esi
incl %esi
movl %esi, %edx
cmpl %r12d, %esi
jl 0x11f7
movl %ebx, %edx
testl %r14d, %r14d
je 0x1218
movl %edx, %ecx
subl %r15d, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x20, %ecx
je 0x121a
shll %cl, %eax
notl %eax
movl %r15d, %ecx
shll %cl, %eax
orl %ebp, %eax
jmp 0x121a
movl %ebp, %eax
xorl $0x1, %r14d
cmpl %ebx, %esi
jl 0x11d9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: rrandom_sf32
F_UINT rrandom_sf(void)
{
    uint32_t a_exp, a_sign;
    F_UINT a_mant;
    a_sign = random() & 1;

    /* generate exponent close to the min/max more often than random */
    switch(random() & 15) {
    case 0:
        a_exp = (random() % (2 * MANT_SIZE)) & EXP_MASK;
        break;
    case 1:
        a_exp = (EXP_MASK - (random() % (2 * MANT_SIZE))) & EXP_MASK;
        break;
    default:
        a_exp = random() & EXP_MASK;
        break;
    }
    a_mant = rrandom_u(MANT_SIZE);
    return pack_sf(a_sign, a_exp, a_mant);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x1090
movq %rax, %rbx
callq 0x1090
movq %rax, %r15
andl $0xf, %r15d
callq 0x1090
movq %rax, %r14
cmpq $0x1, %r15
je 0x127f
testq %r15, %r15
jne 0x12ad
movabsq $-0x4de9bd37a6f4de9b, %rcx # imm = 0xB21642C8590B2165
movq %r14, %rax
imulq %rcx
addq %r14, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x5, %rdx
addl %eax, %edx
imull $0x2e, %edx, %eax
subl %eax, %r14d
jmp 0x12ad
movabsq $-0x4de9bd37a6f4de9b, %rcx # imm = 0xB21642C8590B2165
movq %r14, %rax
imulq %rcx
addq %r14, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x5, %rdx
addl %eax, %edx
imull $0x2e, %edx, %eax
subl %r14d, %eax
addl $0xff, %eax
movl %eax, %r14d
movl $0x17, %edi
callq 0x11bc
shll $0x1f, %ebx
movzbl %r14b, %ecx
shll $0x17, %ecx
orl %ebx, %ecx
andl $0x7fffff, %eax         # imm = 0x7FFFFF
orl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %eax, %eax
movl %eax, 0x8(%rsp)
movl %eax, 0xb(%rsp)
movl %r8d, %eax
leaq 0x14dcc(%rip), %rdi     # 0x160d0
movb (%rdi,%rax,4), %al
movb %al, 0x9(%rsp)
movb $0x1, 0xe(%rsp)
cmpl $0x5, %esi
ja 0x13d7
movl %esi, %eax
leaq 0x14cee(%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 0xaf91
jmp 0x1396
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0x14d40
jmp 0x1396
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0xb50f
jmp 0x1396
leaq 0x8(%rsp), %rsi
movl %edx, %edi
callq 0xc05c
jmp 0x1396
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0xb39e
jmp 0x1396
leaq 0x8(%rsp), %rax
movl %edx, %edi
movl %ecx, %esi
movq %rax, %rdx
callq 0x14e14
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_O1/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:
movb 0x2(%rdi), %al
movl %eax, %ecx
shlb $0x4, %cl
andb $0x10, %cl
leal (%rax,%rax), %edx
andb $0x8, %dl
orb %cl, %dl
movl %eax, %ecx
shrb %cl
andb $0x4, %cl
orb %dl, %cl
movl %eax, %edx
shrb $0x3, %dl
andb $0x2, %dl
orb %cl, %dl
shrb $0x5, %al
andb $0x1, %al
orb %dl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2780
movl $0x1, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2780
movl $0x2, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2780
movl $0x3, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2780
movl $0x4, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2780
movl $0x5, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x2780
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x35fb
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2995
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2bb3
// File: /workspace/github_c_makefile_star2_O1/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 0x24f8
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 0x23e1
movl %ebp, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebx, %r8d
callq 0x1fe9
incl %r12d
cmpl $0x5, %r12d
jne 0x24be
incl %ebx
cmpl $0x3e8, %ebx            # imm = 0x3E8
jne 0x24a4
jmp 0x25a6
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 0x23e1
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 0x1fe9
incl %ebx
cmpl $0xc, %ebx
jne 0x2550
incl %r13d
cmpl $0x5, %r13d
jne 0x253e
movq 0x20(%rsp), %rbx
incl %ebx
addl $0xc, %r14d
cmpl $0xc, %ebx
jne 0x2523
movq 0x10(%rsp), %r14
incl %r14d
movl 0xc(%rsp), %ebx
addl $0x90, %ebx
cmpl $0xc, %r14d
jne 0x24fb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3b59
movl %edi, %eax
leaq 0x1257b(%rip), %rcx     # 0x16070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlq $0x3f, %rdi
jmp 0x3b48
shlq $0x3f, %rdi
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
orq %rax, %rdi
jmp 0x3b50
shlq $0x3f, %rdi
movabsq $0x3fff000000000000, %rax # imm = 0x3FFF000000000000
jmp 0x3b45
shlq $0x3f, %rdi
movabsq $0x7fff800000000000, %rax # imm = 0x7FFF800000000000
jmp 0x3b45
shlq $0x3f, %rdi
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
orq %rax, %rdi
xorl %eax, %eax
jmp 0x3b55
shlq $0x3f, %rdi
movl $0x1, %eax
movq %rdi, %rdx
retq
pushq %rax
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 0x12605(%rip), %rdi     # 0x164b2
movl $0x4, %edx
xorl %eax, %eax
callq 0x1070
leaq 0x12613(%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_O1/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 0x4e0c
movq 0x8(%rsi), %rdi
callq 0x10a0
movl %eax, %edi
callq 0x1050
leaq 0x116c7(%rip), %rdi     # 0x164df
callq 0x1060
xorl %edi, %edi
callq 0x2490
xorl %edi, %edi
callq 0x3909
xorl %edi, %edi
callq 0x4cf2
movl $0x1, %edi
callq 0x2490
movl $0x1, %edi
callq 0x3909
movl $0x1, %edi
callq 0x4cf2
jmp 0x4e32
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x7a81
bsrq %rax, %r10
xorl $0x3f, %r10d
bsrq %rdx, %rcx
xorl $0x3f, %ecx
orl $0x40, %ecx
testq %rax, %rax
cmovnel %r10d, %ecx
jmp 0x7a86
movl $0x80, %ecx
testl %ecx, %ecx
je 0x7aae
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 0x98fc
pushq %rax
leaq 0xea50(%rip), %rdi      # 0x16506
leaq 0xea54(%rip), %rsi      # 0x16511
leaq 0xebb3(%rip), %rcx      # 0x16677
movl $0xb7, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 0x58c0
movl %esi, %edi
notl %edi
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %dil
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %r8b
orb %dil, %r8b
je 0x58c0
movl %esi, %ecx
xorl %eax, %ecx
js 0x592d
testl %eax, %eax
sets %cl
cmpl %esi, %eax
setae %dl
xorb %cl, %dl
jmp 0x5929
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 0x5904
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 0x590d
orb $0x10, (%rdx)
movl $0x7fc00000, %eax       # imm = 0x7FC00000
retq
testb %cl, %cl
je 0x592c
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_O1/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 0x5a3b
movl %esi, %eax
notl %eax
testl $0x7f800000, %eax       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
je 0x5a3b
movl %esi, %eax
orl %edi, %eax
testl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x5a7e
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 0x5a78
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 0x5a78
retq
orb $0x10, (%rdx)
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r10
testl %r8d, %r8d
sete %al
testq %rsi, %rsi
sets %r8b
andb %al, %r8b
xorl %r11d, %r11d
movq %rdi, %rax
negq %rax
sbbq %rsi, %r11
movl %edx, %r9d
testb %r8b, %r8b
cmoveq %rsi, %r11
cmoveq %rdi, %rax
movq %rax, %rcx
orq %r11, %rcx
je 0x60b2
bsrq %r11, %rcx
xorl $0x3f, %ecx
bsrq %rax, %rdx
xorl $0x3f, %edx
orl $0x40, %edx
testq %r11, %r11
cmovnel %ecx, %edx
jmp 0x60b7
movl $0x80, %edx
cmpl $0x60, %edx
ja 0x6119
pushq %r15
pushq %r14
pushq %rbx
movb $0x61, %cl
subb %dl, %cl
movq $-0x1, %rsi
shlq %cl, %rsi
movq %rax, %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 %rax, %r15
xorl %eax, %eax
orq %r14, %r15
setne %al
orl %ebx, %eax
movl $0xfe, %esi
subl %edx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x611e
movl $0x9d, %esi
movzbl %r8b, %edi
movl %eax, %edx
movl %r9d, %ecx
movq %r10, %r8
jmp 0x4fc4
// File: /workspace/github_c_makefile_star2_O1/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 0x6f91
movq %rsi, %r8
notq %r8
testq %r8, %rcx
setne %r8b
testq %rax, %rsi
sete %r9b
orb %r8b, %r9b
je 0x6f91
movq %rsi, %rax
orq %rdi, %rax
shlq %rax
testq %rax, %rax
je 0x6fcf
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 0x6fc9
andq %rsi, %r8
cmpq %rcx, %r8
setne %cl
testq %rax, %rsi
sete %sil
xorl %eax, %eax
orb %cl, %sil
je 0x6fc9
retq
orb $0x10, (%rdx)
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7030
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq %rsi, %r8
notq %r8
testq %r8, %rax
setne %al
testq %rcx, %rsi
sete %cl
orb %al, %cl
je 0x7030
movq %rsi, %rax
xorq %rdi, %rax
js 0x7039
testq %rdi, %rdi
js 0x704e
cmpq %rsi, %rdi
setbe %al
jmp 0x7035
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 0x7035
cmpq %rsi, %rdi
setae %al
jmp 0x7035
// File: /workspace/github_c_makefile_star2_O1/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 0x7245
cmpl $0x7ff, %esi            # imm = 0x7FF
jne 0x7256
testq %r9, %r9
je 0x727c
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
andq %rcx, %rax
movl $0x7fc00000, %edi       # imm = 0x7FC00000
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0x728a
orb $0x10, (%r8)
jmp 0x728a
testq %r9, %r9
je 0x7287
bsrq %r9, %rsi
xorl $-0x40, %esi
addl $0xd, %esi
jmp 0x725c
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 0x4fc4
shll $0x1f, %edi
orl $0x7f800000, %edi       # imm = 0x7F800000
jmp 0x728a
shll $0x1f, %edi
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7a5a
cmpl $0x80, %ecx
jl 0x7a0c
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_O1/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: mul_u128
static F_UINT mul_u(F_UINT *plow, F_UINT a, F_UINT b)
{
    F_UHALF a0, a1, b0, b1, r0, r1, r2, r3;
    F_UINT r00, r01, r10, r11, c;
    a0 = a;
    a1 = a >> FH_SIZE;
    b0 = b;
    b1 = b >> FH_SIZE;

    r00 = (F_UINT)a0 * (F_UINT)b0;
    r01 = (F_UINT)a0 * (F_UINT)b1;
    r10 = (F_UINT)a1 * (F_UINT)b0;
    r11 = (F_UINT)a1 * (F_UINT)b1;
    
    r0 = r00;
    c = (r00 >> FH_SIZE) + (F_UHALF)r01 + (F_UHALF)r10;
    r1 = c;
    c = (c >> FH_SIZE) + (r01 >> FH_SIZE) + (r10 >> FH_SIZE) + (F_UHALF)r11;
    r2 = c;
    r3 = (c >> FH_SIZE) + (r11 >> FH_SIZE);

    *plow = ((F_UINT)r1 << FH_SIZE) | r0;
    return ((F_UINT)r3 << FH_SIZE) | r2;
}

// Assembly:
pushq %r14
pushq %rbx
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %r10
movq %rcx, %rax
mulq %rsi
movq %rdx, %r11
movq %rax, %rcx
movq %r9, %rax
mulq %rsi
movq %rdx, %rbx
movq %rax, %rsi
movq %r8, %rax
mulq %r10
movq %rdx, %r14
movq %rax, %r8
movq %r9, %rax
mulq %r10
xorl %r9d, %r9d
addq %r11, %r8
setb %r9b
xorl %r10d, %r10d
addq %rbx, %r14
setb %r10b
addq %r14, %rax
adcq $0x0, %r10
addq %rsi, %r8
adcq %r9, %rax
movq %rcx, (%rdi)
movq %r8, 0x8(%rdi)
adcq %r10, %rdx
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x884e
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 0x8824
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 0x87f4
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r9, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xded2(%rip), %rdi      # 0x16727
leaq 0xdcb5(%rip), %rsi      # 0x16511
leaq 0xdecb(%rip), %rcx      # 0x1672e
movl $0x23b, %edx            # imm = 0x23B
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 0x917c
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x91a4
movq %rdi, %rax
orq %r9, %rax
je 0x91cd
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movabsq $0x7fff800000000000, %rcx # imm = 0x7FFF800000000000
andq %rcx, %rsi
movabsq $0x7fff000000000000, %rcx # imm = 0x7FFF000000000000
cmpq %rcx, %rsi
jne 0x91e7
orq %r9, %rdi
je 0x91e7
orb $0x10, (%r8)
retq
movq %rdi, %rax
orq %r9, %rax
je 0x91e8
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 0x91aa
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 0x62d8
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_O1/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:
movb 0x5(%rdx), %al
testb %al, %al
je 0x14f13
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %r8b
orb %cl, %r8b
jne 0x14f13
orb $0x40, 0x2(%rdx)
andl $0x80000000, %edi       # imm = 0x80000000
testb %al, %al
je 0x14f37
testl $0x7f800000, %esi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0x14f37
orb $0x40, 0x2(%rdx)
andl $0x80000000, %esi       # imm = 0x80000000
movl %edi, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x7f800000, %eax       # imm = 0x7F800000
ja 0x14f70
movl %esi, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl $0x7f800001, %ecx       # imm = 0x7F800001
jae 0x14f70
cmpl %ecx, %eax
jne 0x14fb7
movl %esi, %eax
xorl %edi, %eax
js 0x14fbc
testl %edi, %edi
sets %al
cmpl %esi, %edi
setae %cl
xorb %al, %cl
cmovnel %esi, %edi
jmp 0x14fb3
leal (%rdi,%rdi), %ecx
cmpl $0xff800000, %ecx       # imm = 0xFF800000
setae %cl
movl %esi, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
cmpl $0x7f800001, %r8d       # imm = 0x7F800001
setb %r8b
testb %r8b, %cl
jne 0x14fc1
cmpl $0x7f800001, %eax       # imm = 0x7F800001
setb %al
leal (%rsi,%rsi), %ecx
cmpl $0xff800000, %ecx       # imm = 0xFF800000
setae %cl
testb %cl, %al
jne 0x14fb3
jmp 0xaeae
movl %edi, %esi
jmp 0x14fc1
cmovbl %edi, %esi
jmp 0x14fc1
testl %edi, %edi
cmovsl %edi, %esi
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9cfd
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testq %rcx, %rax
setne %cl
movq %rax, %rdx
shlq $0xc, %rdx
sete %dl
orb %cl, %dl
jne 0x9cfd
orb $0x40, 0x2(%rsi)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9d0d
movl %edi, %ecx
negl %ecx
jno 0x9d10
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 0x9d2d
bsrl %edx, %ecx
xorl $0x1f, %ecx
jmp 0x9d32
movl $0x20, %ecx
decb %cl
movzbl %cl, %ecx
movl $0x9c, %esi
subq %rcx, %rsi
shll %cl, %edx
movzbl %r8b, %edi
movq %rax, %rcx
jmp 0x9e9b
// File: /workspace/github_c_makefile_star2_O1/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 0x9d92
movl %edi, %eax
shrl $0x1f, %eax
movl %edi, %edx
negl %edx
cmovsl %edi, %edx
bsrl %edx, %esi
xorl $0x1f, %esi
leal 0x15(%rsi), %ecx
shlq %cl, %rdx
shlq $0x34, %rsi
shlq $0x3f, %rax
movabsq $0x4320000000000000, %rcx # imm = 0x4320000000000000
orq %rax, %rcx
subq %rsi, %rcx
movabsq $-0x150000000000000, %rax # imm = 0xFEB0000000000000
addq %rcx, %rax
addq %rdx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9dc2
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 0x9dc6
xorl %eax, %eax
xorl %edi, %edi
movl %edi, %edx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e03
movl %edi, %eax
shrl $0x1f, %eax
movl %edi, %edx
negl %edx
cmovsl %edi, %edx
bsrl %edx, %esi
xorl $0x1f, %esi
leal 0x11(%rsi), %ecx
shlq %cl, %rdx
shlq $0x30, %rsi
shlq $0x3f, %rax
addq %rdx, %rax
subq %rsi, %rax
movabsq $0x401d000000000000, %rdx # imm = 0x401D000000000000
addq %rax, %rdx
xorl %eax, %eax
retq
xorl %eax, %eax
xorl %edx, %edx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e4a
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 0x9e4d
addb $-0x28, %cl
movsbl %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 0x9e86
testb %cl, %cl
je 0x9e89
movl %edi, %ecx
negl %ecx
movl $0x1, %edx
cmpl $0x3f, %ecx
ja 0x9e8c
movq %rsi, %r9
shrq %cl, %r9
negb %cl
shlq %cl, %rsi
xorl %edx, %edx
testq %rsi, %rsi
setne %dl
orq %r9, %rdx
jmp 0x9e8c
shlq %cl, %rsi
movq %rsi, %rdx
movl $0x9c, %esi
subl %edi, %esi
movzbl %al, %edi
movq %r8, %rcx
jmp 0x9e9b
// File: /workspace/github_c_makefile_star2_O1/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 0x9feb
movq %rdi, %rcx
negq %rcx
jno 0x9fef
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 0xa012
bsrq %rdx, %rcx
xorq $0x3f, %rcx
jmp 0xa017
movl $0x40, %ecx
movl $0x43d, %esi            # imm = 0x43D
subq %rcx, %rsi
decb %cl
shlq %cl, %rdx
movzbl %r8b, %edi
movq %rax, %rcx
jmp 0xa1a9
// File: /workspace/github_c_makefile_star2_O1/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 0xa05e
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 0xa062
xorl %eax, %eax
xorl %edi, %edi
movl %edi, %edx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa0dc
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 0xa0c4
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_O1/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 0xa111
bsrq %rdi, %r8
xorq $0x3f, %r8
cmpq $0xffffff, %rdi         # imm = 0xFFFFFF
ja 0xa116
movl $0xffffffd8, %ecx       # imm = 0xFFFFFFD8
addl %r8d, %ecx
shlq %cl, %rdi
shll $0x17, %r8d
subl %r8d, %edi
addl $0x5e800000, %edi       # imm = 0x5E800000
jmp 0xa113
xorl %edi, %edi
movl %edi, %eax
retq
movq %rsi, %rax
movq %rdi, %rcx
shrq $0x1f, %rcx
je 0xa152
movl $0x21, %ecx
subl %r8d, %ecx
je 0xa159
movl $0x1, %edx
cmpl $0x3f, %ecx
ja 0xa15c
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 0xa15c
leal -0x21(%r8), %ecx
shlq %cl, %rdi
movq %rdi, %rdx
movl $0xbd, %esi
subq %r8, %rsi
xorl %edi, %edi
movq %rax, %rcx
jmp 0x9e9b
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: uint64_to_float64
float64 uint64_to_float64(uint64_t a, float_status *status)
{
    int exp = 0x43C;
    int shiftcount;

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

    shiftcount = countLeadingZeros64(a) - 1;
    if (shiftcount < 0) {
        shift64RightJamming(a, -shiftcount, &a);
    } else {
        a <<= shiftcount;
    }
    return roundAndPackFloat64(0, exp - shiftcount, a, status);
}

// Assembly:
testq %rdi, %rdi
je 0xa18b
movq %rsi, %rax
movq %rdi, %rdx
bsrq %rdi, %rdi
xorq $0x3f, %rdi
je 0xa18e
leal -0x1(%rdi), %ecx
shlq %cl, %rdx
jmp 0xa19a
xorl %eax, %eax
retq
movq %rdx, %rcx
shrq %rcx
andl $0x1, %edx
orq %rcx, %rdx
movl $0x43d, %esi            # imm = 0x43D
subq %rdi, %rsi
xorl %edi, %edi
movq %rax, %rcx
jmp 0xa1a9
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: normalizeRoundAndPackFloat128
static float128 normalizeRoundAndPackFloat128(flag zSign, int32 zExp,
                                              uint64_t zSig0, uint64_t zSig1,
                                              float_status *status)
{
    int8 shiftCount;
    uint64_t zSig2;

    if ( zSig0 == 0 ) {
        zSig0 = zSig1;
        zSig1 = 0;
        zExp -= 64;
    }
    shiftCount = countLeadingZeros64( zSig0 ) - 15;
    if ( 0 <= shiftCount ) {
        zSig2 = 0;
        shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
    }
    else {
        shift128ExtraRightJamming(
            zSig0, zSig1, 0, - shiftCount, &zSig0, &zSig1, &zSig2 );
    }
    zExp -= shiftCount;
    return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status);

}

// Assembly:
movq %r8, %r9
movq %rcx, %r11
testq %rdx, %rdx
movq %rdx, %rax
cmoveq %rcx, %rax
cmoveq %rdx, %r11
testq %rax, %rax
je 0xa35e
bsrq %rax, %rcx
xorq $0x3f, %rcx
jmp 0xa363
movl $0x40, %ecx
pushq %r14
pushq %rbx
addb $-0xf, %cl
movsbl %cl, %ebx
movq %rax, %r8
shrq $0x31, %r8
jne 0xa392
movq %r11, %r10
shlq %cl, %r10
testb %cl, %cl
je 0xa38d
movslq %ebx, %rcx
shlq %cl, %rax
negb %cl
shrq %cl, %r11
orq %r11, %rax
xorl %r8d, %r8d
jmp 0xa3fe
testb %cl, %cl
je 0xa3c5
movl %ebx, %r8d
negl %r8d
andb $0x3f, %cl
cmpl $0x3f, %r8d
ja 0xa3cd
movq %r11, %r14
shlq %cl, %r14
movq %rax, %r10
shlq %cl, %r10
movl %r8d, %ecx
shrq %cl, %r11
shrq %cl, %rax
orq %r10, %r11
movq %r11, %r10
xorl %r11d, %r11d
jmp 0xa3f1
xorl %r8d, %r8d
movq %r11, %r10
jmp 0xa3fe
cmpl $0x7f, %r8d
ja 0xa3e6
movq %rax, %r14
shlq %cl, %r14
movq %rax, %r10
movl %r8d, %ecx
shrq %cl, %r10
xorl %eax, %eax
jmp 0xa3f1
movl $0x1, %r14d
xorl %eax, %eax
xorl %r10d, %r10d
xorl %r8d, %r8d
testq %r11, %r11
setne %r8b
orq %r14, %r8
leal -0x40(%rsi), %ecx
testq %rdx, %rdx
cmovnel %esi, %ecx
subl %ebx, %ecx
movzbl %dil, %edi
movl %ecx, %esi
movq %rax, %rdx
movq %r10, %rcx
popq %rbx
popq %r14
jmp 0x12d7b
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_int32
int32 float32_to_int32(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint32_t aSig;
    uint64_t aSig64;

    a = float32_squash_input_denormal(a, status);
    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );
    if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
    if ( aExp ) aSig |= 0x00800000;
    shiftCount = 0xAF - aExp;
    aSig64 = aSig;
    aSig64 <<= 32;
    if ( 0 < shiftCount ) shift64RightJamming( aSig64, shiftCount, &aSig64 );
    return roundAndPackInt32(aSign, aSig64, status);

}

// Assembly:
movq %rsi, %rdx
cmpb $0x0, 0x5(%rsi)
je 0xa446
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xa446
orb $0x40, 0x2(%rdx)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %r8d
andl $0x7fffff, %r8d         # imm = 0x7FFFFF
movl %edi, %eax
shrl $0x17, %eax
movzbl %al, %r9d
leal 0x800000(%r8), %ecx
testl %r9d, %r9d
cmovel %r8d, %ecx
movq %rcx, %rsi
shlq $0x20, %rsi
cmpl $0xae, %r9d
ja 0xa4a6
cmpl $0x70, %r9d
jb 0xa49e
movb $-0x51, %cl
subb %al, %cl
movq %rsi, %r10
shrq %cl, %r10
addb $0x11, %al
movl %eax, %ecx
shlq %cl, %rsi
xorl %eax, %eax
testq %rsi, %rsi
setne %al
orq %r10, %rax
movq %rax, %rsi
jmp 0xa4a6
xorl %esi, %esi
testl %ecx, %ecx
setne %sil
shrl $0x1f, %edi
xorl %eax, %eax
cmpl $0xff, %r9d
cmovnel %edi, %eax
testl %r8d, %r8d
cmovel %edi, %eax
movl %eax, %edi
jmp 0xa4bf