LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: propagateFloat32NaN
static float32 propagateFloat32NaN(float32 a, float32 b, float_status *status)
{
    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    flag aIsLargerSignificand;
    uint32_t av, bv;

    aIsQuietNaN = float32_is_quiet_nan( a );
    aIsSignalingNaN = float32_is_signaling_nan( a );
    bIsQuietNaN = float32_is_quiet_nan( b );
    bIsSignalingNaN = float32_is_signaling_nan( b );
    av = float32_val(a);
    bv = float32_val(b);

    if (aIsSignalingNaN | bIsSignalingNaN) {
        float_raise(float_flag_invalid, status);
    }

    if (status->default_nan_mode)
        return float32_default_nan;

    if ((uint32_t)(av<<1) < (uint32_t)(bv<<1)) {
        aIsLargerSignificand = 0;
    } else if ((uint32_t)(bv<<1) < (uint32_t)(av<<1)) {
        aIsLargerSignificand = 1;
    } else {
        aIsLargerSignificand = (av < bv) ? 1 : 0;
    }

    if (pickNaN(aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN,
                aIsLargerSignificand)) {
        return float32_maybe_silence_nan(b);
    } else {
        return float32_maybe_silence_nan(a);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rcx
movl %esi, %ebx
movl %edi, %r14d
leal (%r14,%r14), %r10d
movl $0xff800000, %r9d       # imm = 0xFF800000
xorl %edi, %edi
cmpl %r9d, %r10d
setae %sil
movl $0x7fc00000, %eax       # imm = 0x7FC00000
movl %r14d, %ebp
andl %eax, %ebp
movl $0x7f800000, %r11d      # imm = 0x7F800000
cmpl %r11d, %ebp
sete %dl
testl $0x3fffff, %r14d        # imm = 0x3FFFFF
setne %r8b
andb %dl, %r8b
leal (%rbx,%rbx), %r12d
xorl %edx, %edx
cmpl %r9d, %r12d
setae %r9b
movl %ebx, %r15d
andl %eax, %r15d
cmpl %r11d, %r15d
sete %r13b
testl $0x3fffff, %ebx         # imm = 0x3FFFFF
setne %r11b
andb %r13b, %r11b
movl %r8d, %r13d
orb %r11b, %r13b
cmpb $0x1, %r13b
jne 0xa437
orb $0x1, 0x2(%rcx)
cmpb $0x0, 0x6(%rcx)
jne 0xa4a4
cmpl %r12d, %r10d
jae 0xa446
xorl %eax, %eax
jmp 0xa450
movb $0x1, %al
ja 0xa450
cmpl %ebx, %r14d
setb %al
movb %sil, %dil
movzbl %r8b, %esi
movb %r9b, %dl
movzbl %r11b, %ecx
movzbl %al, %r8d
callq 0x1336a
testl %eax, %eax
je 0xa487
movl %ebx, %eax
orl $0x400000, %eax         # imm = 0x400000
testl $0x3fffff, %ebx         # imm = 0x3FFFFF
cmovel %ebx, %eax
cmpl $0x7f800000, %r15d      # imm = 0x7F800000
cmovnel %ebx, %eax
jmp 0xa4a4
movl %r14d, %eax
orl $0x400000, %eax         # imm = 0x400000
testl $0x3fffff, %r14d        # imm = 0x3FFFFF
cmovel %r14d, %eax
cmpl $0x7f800000, %ebp       # imm = 0x7F800000
cmovnel %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_add
float32 float32_add(float32 a, float32 b, float_status *status)
{
    flag aSign, bSign;
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    aSign = extractFloat32Sign( a );
    bSign = extractFloat32Sign( b );
    if ( aSign == bSign ) {
        return addFloat32Sigs(a, b, aSign, status);
    }
    else {
        return subFloat32Sigs(a, b, aSign, status);
    }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdx, %rsi
callq 0x91e7
movl %eax, %ebp
movl %r14d, %edi
movq %rbx, %rsi
callq 0x91e7
movl %ebp, %ecx
shrl $0x1f, %ecx
movl %eax, %edx
shrl $0x1f, %edx
cmpl %edx, %ecx
jne 0xa4f0
movzbl %cl, %edx
movl %ebp, %edi
movl %eax, %esi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0xa503
movzbl %cl, %edx
movl %ebp, %edi
movl %eax, %esi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0xa6a1
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: estimateDiv128To64
static uint64_t estimateDiv128To64( uint64_t a0, uint64_t a1, uint64_t b )
{
    uint64_t b0, b1;
    uint64_t rem0, rem1, term0, term1;
    uint64_t z;

    if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF );
    b0 = b>>32;
    z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32;
    mul64To128( b, z, &term0, &term1 );
    sub128( a0, a1, term0, term1, &rem0, &rem1 );
    while ( ( (int64_t) rem0 ) < 0 ) {
        z -= LIT64( 0x100000000 );
        b1 = b<<32;
        add128( rem0, rem1, b0, b1, &rem0, &rem1 );
    }
    rem0 = ( rem0<<32 ) | ( rem1>>32 );
    z |= ( b0<<32 <= rem0 ) ? 0xFFFFFFFF : rem0 / b0;
    return z;

}

// Assembly:
cmpq %rdi, %rdx
jbe 0xae71
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
movq %rdx, %r13
shrq $0x20, %r13
movq %rdx, %rax
andq %rbp, %rax
movq %rbp, %r14
movq %rax, (%rsp)
cmpq %rdi, %rax
jbe 0xae0e
movq %rbx, %rax
xorl %edx, %edx
divq %r13
movq %rax, %r14
shlq $0x20, %r14
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0xd0a6
leaq 0x8(%rsp), %rax
subq (%rax), %r15
leaq 0x10(%rsp), %rax
sbbq (%rax), %rbx
shlq $0x20, %r12
testq %rbx, %rbx
jns 0xae47
addq %rbp, %r14
addq %r12, %r15
adcq %r13, %rbx
jmp 0xae37
shldq $0x20, %r15, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rbx, (%rsp)
jbe 0xae5f
movq %rbx, %rax
xorl %edx, %edx
divq %r13
orq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_sqrt
float32 float32_sqrt(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, zExp;
    uint32_t aSig, zSig;
    uint64_t rem, term;
    a = float32_squash_input_denormal(a, status);

    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );
    if ( aExp == 0xFF ) {
        if (aSig) {
            return propagateFloat32NaN(a, float32_zero, status);
        }
        if ( ! aSign ) return a;
        float_raise(float_flag_invalid, status);
        return float32_default_nan;
    }
    if ( aSign ) {
        if ( ( aExp | aSig ) == 0 ) return a;
        float_raise(float_flag_invalid, status);
        return float32_default_nan;
    }
    if ( aExp == 0 ) {
        if ( aSig == 0 ) return float32_zero;
        normalizeFloat32Subnormal( aSig, &aExp, &aSig );
    }
    zExp = ( ( aExp - 0x7F )>>1 ) + 0x7E;
    aSig = ( aSig | 0x00800000 )<<8;
    zSig = estimateSqrt32( aExp, aSig ) + 2;
    if ( ( zSig & 0x7F ) <= 5 ) {
        if ( zSig < 2 ) {
            zSig = 0x7FFFFFFF;
            goto roundAndPack;
        }
        aSig >>= aExp & 1;
        term = ( (uint64_t) zSig ) * zSig;
        rem = ( ( (uint64_t) aSig )<<32 ) - term;
        while ( (int64_t) rem < 0 ) {
            --zSig;
            rem += ( ( (uint64_t) zSig )<<1 ) | 1;
        }
        zSig |= ( rem != 0 );
    }
    shift32RightJamming( zSig, 1, &zSig );
 roundAndPack:
    return roundAndPackFloat32(0, zExp, zSig, status);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x91e7
movl %eax, %r14d
andl $0x7fffff, %r14d        # imm = 0x7FFFFF
movl %eax, %r12d
shrl $0x17, %r12d
movl $0xff, %ecx
andl %ecx, %r12d
cmpl %ecx, %r12d
jne 0xb42d
testl %r14d, %r14d
je 0xb4b8
movl %eax, %edi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa3b6
testl %eax, %eax
js 0xb4be
testq %r12, %r12
jne 0xb458
testl %r14d, %r14d
je 0xb503
bsrl %r14d, %eax
xorl $0x1f, %eax
leal -0x8(%rax), %ecx
shll %cl, %r14d
pushq $0x9
popq %rcx
subl %eax, %ecx
movslq %ecx, %r12
leaq -0x7f(%r12), %r15
sarq %r15
addq $0x7e, %r15
shll $0x8, %r14d
orl $0x80000000, %r14d      # imm = 0x80000000
movq %r12, %rdi
movl %r14d, %esi
callq 0xb507
leal 0x2(%rax), %esi
movl %esi, %ecx
andl $0x7e, %ecx
cmpl $0x5, %ecx
ja 0xb4e0
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpl $-0x3, %eax
ja 0xb4eb
andb $0x1, %r12b
movl %r12d, %ecx
shrl %cl, %r14d
movl %esi, %eax
imulq %rax, %rax
shlq $0x20, %r14
subq %rax, %r14
testq %r14, %r14
jns 0xb4d8
decl %esi
leaq (%r14,%rsi,2), %r14
incq %r14
jmp 0xb4a8
testl %eax, %eax
jns 0xb4cc
jmp 0xb4c3
orl %r14d, %r12d
je 0xb4cc
orb $0x1, 0x2(%rbx)
movl $0x7fc00000, %eax       # imm = 0x7FC00000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
setne %al
movzbl %al, %eax
orl %eax, %esi
movl %esi, %eax
shrl %eax
andl $0x1, %esi
orl %eax, %esi
movl %esi, %edx
xorl %edi, %edi
movq %r15, %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9421
xorl %eax, %eax
jmp 0xb4cc
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: estimateSqrt32
static uint32_t estimateSqrt32(int_fast16_t aExp, uint32_t a)
{
    static const uint16_t sqrtOddAdjustments[] = {
        0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
        0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
    };
    static const uint16_t sqrtEvenAdjustments[] = {
        0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
        0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
    };
    int8 index;
    uint32_t z;

    index = ( a>>27 ) & 15;
    if ( aExp & 1 ) {
        z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ (int)index ];
        z = ( ( a / z )<<14 ) + ( z<<15 );
        a >>= 1;
    }
    else {
        z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ (int)index ];
        z = a / z + z;
        z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );
        if ( z <= a ) return (uint32_t) ( ( (int32_t) a )>>1 );
    }
    return ( (uint32_t) ( ( ( (uint64_t) a )<<31 ) / z ) ) + ( z>>1 );

}

// Assembly:
movl %esi, %eax
shrl $0x1b, %eax
testb $0x1, %dil
jne 0xb551
movl %esi, %ecx
shrl $0x11, %ecx
orl $0x8000, %ecx           # imm = 0x8000
andl $0xf, %eax
leaq 0x94b9(%rip), %rdx      # 0x149e0
movzwl (%rdx,%rax,2), %eax
subl %eax, %ecx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
addl %ecx, %eax
movl %eax, %edx
shll $0xf, %edx
cmpl $0x20000, %eax          # imm = 0x20000
movl $0xffff8000, %ecx       # imm = 0xFFFF8000
cmovbl %edx, %ecx
cmpl %esi, %ecx
ja 0xb57c
sarl %esi
movl %esi, %ecx
jmp 0xb58d
andl $0xf, %eax
movl %esi, %ecx
shrl $0x11, %ecx
leaq 0x9460(%rip), %rdx      # 0x149c0
movzwl (%rdx,%rax,2), %eax
subl %eax, %ecx
addl $0x4000, %ecx           # imm = 0x4000
movl %esi, %eax
xorl %edx, %edx
divl %ecx
shll $0xe, %eax
shll $0xf, %ecx
addl %eax, %ecx
shrl %esi
movl %esi, %eax
shlq $0x1f, %rax
movl %ecx, %esi
xorl %edx, %edx
divq %rsi
shrl %ecx
addl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift32RightJamming
static inline void shift32RightJamming(uint32_t a, int_fast16_t count, uint32_t *zPtr)
{
    uint32_t z;

    if ( count == 0 ) {
        z = a;
    }
    else if ( count < 32 ) {
        z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );
    }
    else {
        z = ( a != 0 );
    }
    *zPtr = z;

}

// Assembly:
testq %rsi, %rsi
je 0xb5be
cmpq $0x1f, %rsi
jg 0xb5b5
movl %edi, %eax
movl %esi, %ecx
shrl %cl, %eax
negb %sil
movl %esi, %ecx
shll %cl, %edi
xorl %ecx, %ecx
testl %edi, %edi
setne %cl
orl %eax, %ecx
movl %ecx, %edi
jmp 0xb5be
xorl %eax, %eax
testl %edi, %edi
setne %al
movl %eax, %edi
movl %edi, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_exp2
float32 float32_exp2(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;
    float64 r, x, xn;
    int i;
    a = float32_squash_input_denormal(a, status);

    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );

    if ( aExp == 0xFF) {
        if (aSig) {
            return propagateFloat32NaN(a, float32_zero, status);
        }
        return (aSign) ? float32_zero : a;
    }
    if (aExp == 0) {
        if (aSig == 0) return float32_one;
    }

    float_raise(float_flag_inexact, status);

    /* ******************************* */
    /* using float64 for approximation */
    /* ******************************* */
    x = float32_to_float64(a, status);
    x = float64_mul(x, float64_ln2, status);

    xn = x;
    r = float64_one;
    for (i = 0 ; i < 15 ; i++) {
        float64 f;

        f = float64_mul(xn, float32_exp2_coefficients[i], status);
        r = float64_add(r, f, status);

        xn = float64_mul(xn, x, status);
    }

    return float64_to_float32(r, status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x91e7
movl %eax, %ecx
andl $0x7fffff, %ecx         # imm = 0x7FFFFF
movl %eax, %edx
shrl $0x17, %edx
movl $0xff, %esi
andl %esi, %edx
cmpl %esi, %edx
jne 0xb60e
testl %ecx, %ecx
je 0xb6aa
movl %eax, %edi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa3b6
orl %ecx, %edx
je 0xb6b5
orb $0x20, 0x2(%rbx)
movl %eax, %edi
movq %rbx, %rsi
callq 0x9fcc
movabsq $0x3fe62e42fefa39ef, %rsi # imm = 0x3FE62E42FEFA39EF
movq %rax, %rdi
movq %rbx, %rdx
callq 0xb6c9
movq %rax, %r14
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
xorl %r13d, %r13d
leaq 0x92f0(%rip), %rbp      # 0x14940
movq %rax, %r12
cmpq $0x78, %r13
je 0xb691
movq (%r13,%rbp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0xb6c9
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xb88b
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb6c9
movq %rax, %r12
addq $0x8, %r13
jmp 0xb653
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb8eb
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, %eax
jmp 0xb6ba
movl $0x3f800000, %eax       # imm = 0x3F800000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_add
float64 float64_add(float64 a, float64 b, float_status *status)
{
    flag aSign, bSign;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    aSign = extractFloat64Sign( a );
    bSign = extractFloat64Sign( b );
    if ( aSign == bSign ) {
        return addFloat64Sigs(a, b, aSign, status);
    }
    else {
        return subFloat64Sigs(a, b, aSign, status);
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdx, %rsi
callq 0x920d
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x920d
movq %r14, %rcx
shrq $0x3f, %rcx
movq %rax, %rdx
shrq $0x3f, %rdx
cmpq %rdx, %rcx
jne 0xb8d5
movzbl %cl, %edx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xccd2
movzbl %cl, %edx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xce85
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_float32
float32 float64_to_float32(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig;
    uint32_t zSig;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp == 0x7FF ) {
        if (aSig) {
            return commonNaNToFloat32(float64ToCommonNaN(a, status), status);
        }
        return packFloat32( aSign, 0xFF, 0 );
    }
    shift64RightJamming( aSig, 22, &aSig );
    zSig = aSig;
    if ( aExp || zSig ) {
        zSig |= 0x40000000;
        aExp -= 0x381;
    }
    return roundAndPackFloat32(aSign, aExp, zSig, status);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
callq 0x920d
movq %rax, %rsi
movabsq $0xfffffffffffff, %rdx  # imm = 0xFFFFFFFFFFFFF
andq %rax, %rdx
movq %rax, %rcx
shrq $0x34, %rcx
movl $0x7ff, %edi            # imm = 0x7FF
andq %rdi, %rcx
shrq $0x3f, %rax
cmpq %rdi, %rcx
jne 0xb95e
testq %rdx, %rdx
je 0xb9a0
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xc2e4
movq 0x8(%r14), %rax
shrq $0x29, %rax
movl (%r14), %ecx
shll $0x1f, %ecx
testq %rax, %rax
leal 0x7f800000(%rcx,%rax), %eax
movl $0x7fc00000, %ecx       # imm = 0x7FC00000
cmovel %ecx, %eax
cmpb $0x0, 0x6(%rbx)
cmovnel %ecx, %eax
jmp 0xb9a8
shrq $0x16, %rdx
xorl %edi, %edi
shlq $0x2a, %rsi
setne %dil
orq %rdx, %rdi
leal 0x40000000(%rdi), %edx
leaq -0x381(%rcx), %r8
xorl %r9d, %r9d
orq %rcx, %rdi
movl $0x0, %esi
cmovneq %r8, %rsi
cmovel %r9d, %edx
movl %eax, %edi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x9421
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_log2
float32 float32_log2(float32 a, float_status *status)
{
    flag aSign, zSign;
    int_fast16_t aExp;
    uint32_t aSig, zSig, i;

    a = float32_squash_input_denormal(a, status);
    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );

    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloat32( 1, 0xFF, 0 );
        normalizeFloat32Subnormal( aSig, &aExp, &aSig );
    }
    if ( aSign ) {
        float_raise(float_flag_invalid, status);
        return float32_default_nan;
    }
    if ( aExp == 0xFF ) {
        if (aSig) {
            return propagateFloat32NaN(a, float32_zero, status);
        }
        return a;
    }

    aExp -= 0x7F;
    aSig |= 0x00800000;
    zSign = aExp < 0;
    zSig = aExp << 23;

    for (i = 1 << 22; i > 0; i >>= 1) {
        aSig = ( (uint64_t)aSig * aSig ) >> 23;
        if ( aSig & 0x01000000 ) {
            aSig >>= 1;
            zSig |= i;
        }
    }

    if ( zSign )
        zSig = -zSig;

    return normalizeRoundAndPackFloat32(zSign, 0x85, zSig, status);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x91e7
movl %eax, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %eax, %ecx
shrl $0x17, %ecx
movzbl %cl, %esi
testl %esi, %esi
jne 0xb9e8
testl %edx, %edx
je 0xba72
bsrl %edx, %esi
xorl $0x1f, %esi
leal -0x8(%rsi), %ecx
shll %cl, %edx
pushq $0x9
popq %rcx
subl %esi, %ecx
movslq %ecx, %rsi
testl %eax, %eax
js 0xba06
cmpq $0xff, %rsi
jne 0xba11
testl %edx, %edx
je 0xba77
movl %eax, %edi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0xa3b6
orb $0x1, 0x2(%rbx)
movl $0x7fc00000, %eax       # imm = 0x7FC00000
jmp 0xba77
orl $0x800000, %edx         # imm = 0x800000
movl %esi, %eax
shll $0x17, %eax
addl $0xc0800000, %eax       # imm = 0xC0800000
movl $0x400000, %edi         # imm = 0x400000
testl %edi, %edi
je 0xba53
movl %edx, %edx
imulq %rdx, %rdx
shrq $0x17, %rdx
movl %edx, %r8d
shll $0x7, %r8d
movl %edx, %ecx
shrl $0x18, %ecx
andl $0x1, %ecx
shrl %cl, %edx
sarl $0x1f, %r8d
andl %edi, %r8d
orl %r8d, %eax
shrl %edi
jmp 0xba26
movl %eax, %edx
negl %edx
xorl %edi, %edi
cmpq $0x7f, %rsi
setl %dil
cmovgel %eax, %edx
movl $0x85, %esi
movq %rbx, %rcx
popq %rbx
jmp 0x9270
movl $0xff800000, %eax       # imm = 0xFF800000
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_eq
int float32_eq(float32 a, float32 b, float_status *status)
{
    uint32_t av, bv;
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    av = float32_val(a);
    bv = float32_val(b);
    return ( av == bv ) || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdx, %rsi
callq 0x91e7
movl %eax, %ebp
movl %r14d, %edi
movq %rbx, %rsi
callq 0x91e7
movl %ebp, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
sete %cl
testl $0x7fffff, %ebp         # imm = 0x7FFFFF
setne %dl
testb %dl, %cl
jne 0xbae1
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %eax         # imm = 0x7FFFFF
sete %dl
orb %cl, %dl
je 0xbae1
cmpl %eax, %ebp
sete %cl
orl %ebp, %eax
testl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
sete %al
orb %cl, %al
movzbl %al, %eax
jmp 0xbae7
orb $0x1, 0x2(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_le
int float32_le(float32 a, float32 b, float_status *status)
{
    flag aSign, bSign;
    uint32_t av, bv;
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    aSign = extractFloat32Sign( a );
    bSign = extractFloat32Sign( b );
    av = float32_val(a);
    bv = float32_val(b);
    if ( aSign != bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
    return ( av == bv ) || ( aSign ^ ( av < bv ) );

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdx, %rsi
callq 0x91e7
movl %eax, %ebx
movl %ebp, %edi
movq %r14, %rsi
callq 0x91e7
movl %ebx, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
sete %cl
testl $0x7fffff, %ebx         # imm = 0x7FFFFF
setne %dl
testb %dl, %cl
jne 0xbb53
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %eax         # imm = 0x7FFFFF
sete %dl
orb %cl, %dl
je 0xbb53
movl %eax, %ecx
xorl %ebx, %ecx
js 0xbb5c
cmpl %eax, %ebx
sete %cl
setb %dl
testl %ebx, %ebx
sets %al
xorb %dl, %al
jmp 0xbb6b
orb $0x1, 0x2(%r14)
xorl %eax, %eax
jmp 0xbb6d
testl %ebx, %ebx
sets %cl
orl %ebx, %eax
testl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
sete %al
orb %cl, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_unordered
int float32_unordered(float32 a, float32 b, float_status *status)
{
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdx, %rsi
callq 0x91e7
movl %eax, %r14d
movl %ebp, %edi
movq %rbx, %rsi
callq 0x91e7
movl %r14d, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
sete %cl
testl $0x7fffff, %r14d        # imm = 0x7FFFFF
setne %dl
testb %dl, %cl
jne 0xbc53
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %eax         # imm = 0x7FFFFF
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0xbc5a
orb $0x1, 0x2(%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_eq_quiet
int float32_eq_quiet(float32 a, float32 b, float_status *status)
{
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 0;
    }
    return ( float32_val(a) == float32_val(b) ) ||
            ( (uint32_t) ( ( float32_val(a) | float32_val(b) )<<1 ) == 0 );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdx, %rsi
callq 0x91e7
movl %eax, %ebp
movl %r14d, %edi
movq %rbx, %rsi
callq 0x91e7
movl %ebp, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
sete %cl
testl $0x7fffff, %ebp         # imm = 0x7FFFFF
setne %dl
testb %dl, %cl
jne 0xbcc7
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %eax         # imm = 0x7FFFFF
sete %dl
orb %cl, %dl
je 0xbcc7
cmpl %eax, %ebp
sete %cl
orl %ebp, %eax
testl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
sete %al
orb %cl, %al
movzbl %al, %eax
jmp 0xbd0a
movl %ebp, %ecx
andl $0x7fc00000, %ecx       # imm = 0x7FC00000
cmpl $0x7f800000, %ecx       # imm = 0x7F800000
sete %cl
testl $0x3fffff, %ebp         # imm = 0x3FFFFF
setne %dl
testb %dl, %cl
jne 0xbd04
movl %eax, %ecx
andl $0x7fc00000, %ecx       # imm = 0x7FC00000
cmpl $0x7f800000, %ecx       # imm = 0x7F800000
setne %cl
testl $0x3fffff, %eax         # imm = 0x3FFFFF
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0xbd0a
orb $0x1, 0x2(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_unordered_quiet
int float32_unordered_quiet(float32 a, float32 b, float_status *status)
{
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdx, %rsi
callq 0x91e7
movl %eax, %ebp
movl %r14d, %edi
movq %rbx, %rsi
callq 0x91e7
movl %ebp, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
sete %cl
testl $0x7fffff, %ebp         # imm = 0x7FFFFF
setne %dl
testb %dl, %cl
jne 0xbeef
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
setne %dl
testl $0x7fffff, %eax         # imm = 0x7FFFFF
sete %sil
xorl %ecx, %ecx
orb %dl, %sil
jne 0xbf33
movl %ebp, %ecx
andl $0x7fc00000, %ecx       # imm = 0x7FC00000
cmpl $0x7f800000, %ecx       # imm = 0x7F800000
sete %dl
testl $0x3fffff, %ebp         # imm = 0x3FFFFF
setne %sil
pushq $0x1
popq %rcx
testb %sil, %dl
jne 0xbf2f
movl %eax, %edx
andl $0x7fc00000, %edx       # imm = 0x7FC00000
cmpl $0x7f800000, %edx       # imm = 0x7F800000
setne %dl
testl $0x3fffff, %eax         # imm = 0x3FFFFF
sete %al
orb %dl, %al
jne 0xbf33
orb $0x1, 0x2(%rbx)
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int32
int32 float64_to_int32(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
    if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
    shiftCount = 0x42C - aExp;
    if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
    return roundAndPackInt32(aSign, aSig, status);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movabsq $0xfffffffffffff, %r15  # imm = 0xFFFFFFFFFFFFF
callq 0x920d
movq %rax, %r14
movq %rax, %r12
andq %r15, %r12
movq %r12, 0x8(%rsp)
movq %rax, %r13
shrq $0x34, %r13
movq %r12, %rsi
andq $0x7ff, %r13            # imm = 0x7FF
je 0xbf8f
leaq (%r15,%r12), %rsi
incq %rsi
movq %rsi, 0x8(%rsp)
cmpl $0x42b, %r13d           # imm = 0x42B
ja 0xbfad
movl $0x42c, %eax            # imm = 0x42C
subq %r13, %rax
leaq 0x8(%rsp), %r15
movq %rsi, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x93e7
movq (%r15), %rsi
shrq $0x3f, %r14
xorl %edi, %edi
cmpl $0x7ff, %r13d           # imm = 0x7FF
cmovnel %r14d, %edi
testq %r12, %r12
cmovel %r14d, %edi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9a4b
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int32_round_to_zero
int32 float64_to_int32_round_to_zero(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig, savedASig;
    int32_t z;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( 0x41E < aExp ) {
        if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
        goto invalid;
    }
    else if ( aExp < 0x3FF ) {
        if (aExp || aSig) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    aSig |= LIT64( 0x0010000000000000 );
    shiftCount = 0x433 - aExp;
    savedASig = aSig;
    aSig >>= shiftCount;
    z = aSig;
    if ( aSign ) z = - z;
    if ( ( z < 0 ) ^ aSign ) {
 invalid:
        float_raise(float_flag_invalid, status);
        return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
    }
    if ( ( aSig<<shiftCount ) != savedASig ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movabsq $0xfffffffffffff, %r14  # imm = 0xFFFFFFFFFFFFF
callq 0x920d
movq %rax, %rcx
andq %r14, %rcx
movq %rax, %rdi
shrq $0x34, %rdi
andl $0x7ff, %edi            # imm = 0x7FF
movq %rax, %rsi
shrq $0x3f, %rsi
cmpq $0x41f, %rdi            # imm = 0x41F
jb 0xc03c
movzbl %sil, %eax
xorl %edx, %edx
cmpl $0x7ff, %edi            # imm = 0x7FF
cmovnel %eax, %edx
testq %rcx, %rcx
cmovel %eax, %edx
movl %edx, %esi
orb $0x1, 0x2(%rbx)
cmpb $0x1, %sil
movl $0x80000000, %eax       # imm = 0x80000000
sbbl $0x0, %eax
jmp 0xc04f
cmpl $0x3fe, %edi            # imm = 0x3FE
ja 0xc057
xorl %eax, %eax
orq %rcx, %rdi
je 0xc04f
orb $0x20, 0x2(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdx
leaq (%r14,%rcx), %r8
incq %r8
movl $0x433, %ecx            # imm = 0x433
subq %rdi, %rcx
movq %r8, %rdi
shrq %cl, %rdi
movl %edi, %eax
negl %eax
testq %rdx, %rdx
cmovnsl %edi, %eax
movl %eax, %edx
shrl $0x1f, %edx
cmpl %esi, %edx
jne 0xc02a
shlq %cl, %rdi
cmpq %r8, %rdi
jne 0xc04b
jmp 0xc04f
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int16_round_to_zero
int_fast16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig, savedASig;
    int32 z;

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( 0x40E < aExp ) {
        if ( ( aExp == 0x7FF ) && aSig ) {
            aSign = 0;
        }
        goto invalid;
    }
    else if ( aExp < 0x3FF ) {
        if ( aExp || aSig ) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    aSig |= LIT64( 0x0010000000000000 );
    shiftCount = 0x433 - aExp;
    savedASig = aSig;
    aSig >>= shiftCount;
    z = aSig;
    if ( aSign ) {
        z = - z;
    }
    if ( ( (int16_t)z < 0 ) ^ aSign ) {
 invalid:
        float_raise(float_flag_invalid, status);
        return aSign ? (int32_t) 0xffff8000 : 0x7FFF;
    }
    if ( ( aSig<<shiftCount ) != savedASig ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;
}

// Assembly:
movabsq $0xfffffffffffff, %r8   # imm = 0xFFFFFFFFFFFFF
movq %rdi, %rcx
andq %r8, %rcx
movq %rdi, %rdx
shrq $0x34, %rdx
andl $0x7ff, %edx            # imm = 0x7FF
movq %rdi, %rax
shrq $0x3f, %rax
cmpq $0x40f, %rdx            # imm = 0x40F
jb 0xc0e6
movzbl %al, %eax
xorl %edi, %edi
cmpl $0x7ff, %edx            # imm = 0x7FF
cmovnel %eax, %edi
testq %rcx, %rcx
cmovel %eax, %edi
movl %edi, %eax
orb $0x1, 0x2(%rsi)
testb %al, %al
movl $0x7fff, %ecx           # imm = 0x7FFF
movq $-0x8000, %rax          # imm = 0x8000
cmoveq %rcx, %rax
retq
cmpl $0x3fe, %edx            # imm = 0x3FE
ja 0xc0fa
orq %rcx, %rdx
je 0xc0f7
orb $0x20, 0x2(%rsi)
xorl %eax, %eax
retq
addq %rcx, %r8
incq %r8
movl $0x433, %ecx            # imm = 0x433
subq %rdx, %rcx
movq %r8, %r9
shrq %cl, %r9
movl %r9d, %edx
negl %edx
testq %rdi, %rdi
cmovnsl %r9d, %edx
movl %edx, %edi
shrl $0xf, %edi
andl $0x1, %edi
cmpl %eax, %edi
jne 0xc0cf
shlq %cl, %r9
cmpq %r8, %r9
je 0xc132
orb $0x20, 0x2(%rsi)
movslq %edx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int64
int64 float64_to_int64(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig, aSigExtra;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
    shiftCount = 0x433 - aExp;
    if ( shiftCount <= 0 ) {
        if ( 0x43E < aExp ) {
            float_raise(float_flag_invalid, status);
            if (    ! aSign
                 || (    ( aExp == 0x7FF )
                      && ( aSig != LIT64( 0x0010000000000000 ) ) )
               ) {
                return LIT64( 0x7FFFFFFFFFFFFFFF );
            }
            return (int64_t) LIT64( 0x8000000000000000 );
        }
        aSigExtra = 0;
        aSig <<= - shiftCount;
    }
    else {
        shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
    }
    return roundAndPackInt64(aSign, aSig, aSigExtra, status);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movabsq $0xfffffffffffff, %r15  # imm = 0xFFFFFFFFFFFFF
callq 0x920d
movq %rax, %r14
movq %rax, %rdi
andq %r15, %rdi
movq %rdi, 0x8(%rsp)
movq %rax, %rcx
shrq $0x34, %rcx
andq $0x7ff, %rcx            # imm = 0x7FF
je 0xc1c5
leaq (%r15,%rdi), %rsi
incq %rsi
movq %rsi, 0x8(%rsp)
cmpq $0x433, %rcx            # imm = 0x433
jb 0xc1c2
cmpl $0x43f, %ecx            # imm = 0x43F
jb 0xc206
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%rbx)
testq %r14, %r14
jns 0xc1b6
leaq 0x1(%rax), %rdx
testq %rdi, %rdi
cmoveq %rdx, %rax
cmpl $0x7ff, %ecx            # imm = 0x7FF
cmovneq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %rdi
movl $0x433, %edx            # imm = 0x433
subq %rcx, %rdx
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
xorl %esi, %esi
movq %r15, %rcx
movq %r12, %r8
callq 0x9cb8
movq (%r15), %rsi
movq (%r12), %rdx
shrq $0x3f, %r14
movzbl %r14b, %edi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9d0f
addq $-0x433, %rcx           # imm = 0xFBCD
shlq %cl, %rsi
xorl %edx, %edx
jmp 0xc1eb
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int64_round_to_zero
int64 float64_to_int64_round_to_zero(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig;
    int64 z;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
    shiftCount = aExp - 0x433;
    if ( 0 <= shiftCount ) {
        if ( 0x43E <= aExp ) {
            if ( float64_val(a) != LIT64( 0xC3E0000000000000 ) ) {
                float_raise(float_flag_invalid, status);
                if (    ! aSign
                     || (    ( aExp == 0x7FF )
                          && ( aSig != LIT64( 0x0010000000000000 ) ) )
                   ) {
                    return LIT64( 0x7FFFFFFFFFFFFFFF );
                }
            }
            return (int64_t) LIT64( 0x8000000000000000 );
        }
        z = aSig<<shiftCount;
    }
    else {
        if ( aExp < 0x3FE ) {
            if (aExp | aSig) {
                status->float_exception_flags |= float_flag_inexact;
            }
            return 0;
        }
        z = aSig>>( - shiftCount );
        if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) {
            status->float_exception_flags |= float_flag_inexact;
        }
    }
    if ( aSign ) z = - z;
    return z;

}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x920d
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq %rax, %r8
andq %rcx, %r8
movq %rax, %rsi
shrq $0x34, %rsi
andl $0x7ff, %esi            # imm = 0x7FF
leaq 0x1(%r8,%rcx), %rdi
movq %rdi, %rcx
cmoveq %r8, %rcx
leaq -0x433(%rsi), %rdx
cmpq $0x433, %rsi            # imm = 0x433
jb 0xc27c
cmpl $0x43e, %esi            # imm = 0x43E
jb 0xc291
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movabsq $-0x3c20000000000000, %rdx # imm = 0xC3E0000000000000
cmpq %rdx, %rax
jne 0xc2c6
incq %rcx
jmp 0xc2c1
cmpl $0x3fd, %esi            # imm = 0x3FD
ja 0xc29b
orq %rsi, %rcx
je 0xc28d
orb $0x20, 0x2(%rbx)
xorl %ecx, %ecx
jmp 0xc2c1
movl %edx, %ecx
shlq %cl, %rdi
movq %rdi, %rsi
jmp 0xc2b4
movb $0x33, %cl
subb %sil, %cl
movq %rdi, %rsi
shrq %cl, %rsi
movl %edx, %ecx
shlq %cl, %rdi
testq %rdi, %rdi
je 0xc2b4
orb $0x20, 0x2(%rbx)
movq %rsi, %rcx
negq %rcx
testq %rax, %rax
cmovnsq %rsi, %rcx
movq %rcx, %rax
popq %rbx
retq
orb $0x1, 0x2(%rbx)
testq %rax, %rax
jns 0xc2c1
cmpl $0x7ff, %esi            # imm = 0x7FF
sete %al
testq %r8, %r8
setne %dl
testb %al, %dl
je 0xc277
jmp 0xc2c1
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float64ToCommonNaN
static commonNaNT float64ToCommonNaN(float64 a, float_status *status)
{
    commonNaNT z;

    if (float64_is_signaling_nan(a)) {
        float_raise(float_flag_invalid, status);
    }
    z.sign = float64_val(a)>>63;
    z.low = 0;
    z.high = float64_val(a)<<12;
    return z;
}

// Assembly:
movq %rdi, %rax
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
andq %rsi, %rcx
movabsq $0x7ff0000000000000, %rdi # imm = 0x7FF0000000000000
cmpq %rdi, %rcx
setne %cl
movq %rsi, %rdi
shlq $0xd, %rdi
sete %dil
orb %cl, %dil
jne 0xc318
orb $0x1, 0x2(%rdx)
movq %rsi, %rcx
shrq $0x3f, %rcx
movb %cl, (%rax)
andq $0x0, 0x10(%rax)
shlq $0xc, %rsi
movq %rsi, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float16_to_float32
float32 float16_to_float32(float16 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;

    aSign = extractFloat16Sign(a);
    aExp = extractFloat16Exp(a);
    aSig = extractFloat16Frac(a);

    if (aExp == 0x1f && ieee) {
        if (aSig) {
            return commonNaNToFloat32(float16ToCommonNaN(a, status), status);
        }
        return packFloat32(aSign, 0xff, 0);
    }
    if (aExp == 0) {
        if (aSig == 0) {
            return packFloat32(aSign, 0, 0);
        }

        normalizeFloat16Subnormal(aSig, &aExp, &aSig);
        aExp--;
    }
    return packFloat32( aSign, aExp + 0x70, aSig << 13);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %edi, %eax
shrl $0xf, %eax
movl %edi, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %edi, %edx
andl $0x3ff, %edx            # imm = 0x3FF
cmpw $0x1f, %cx
setne %r8b
testl %esi, %esi
sete %sil
orb %r8b, %sil
jne 0xc39f
testl %edx, %edx
je 0xc3a9
movzwl %di, %esi
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xc3e7
movq 0x8(%r14), %rax
shrq $0x29, %rax
movl (%r14), %ecx
shll $0x1f, %ecx
testq %rax, %rax
leal 0x7f800000(%rcx,%rax), %eax
movl $0x7fc00000, %ecx       # imm = 0x7FC00000
cmovel %ecx, %eax
cmpb $0x0, 0x6(%rbx)
cmovnel %ecx, %eax
jmp 0xc3da
testw %cx, %cx
je 0xc3b3
movzwl %cx, %ecx
jmp 0xc3c7
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
jmp 0xc3da
testl %edx, %edx
je 0xc3e2
bsrl %edx, %esi
xorl $0x1f, %esi
leal -0x15(%rsi), %ecx
shll %cl, %edx
pushq $0x15
popq %rcx
subl %esi, %ecx
shll $0xd, %edx
shll $0x1f, %eax
shll $0x17, %ecx
addl %eax, %ecx
leal (%rdx,%rcx), %eax
addl $0x38000000, %eax       # imm = 0x38000000
addq $0x18, %rsp
popq %rbx
popq %r14
retq
shll $0x1f, %eax
jmp 0xc3da
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float16ToCommonNaN
static commonNaNT float16ToCommonNaN(float16 a, float_status *status)
{
    commonNaNT z;

    if (float16_is_signaling_nan(a)) {
        float_raise(float_flag_invalid, status);
    }
    z.sign = float16_val(a) >> 15;
    z.low = 0;
    z.high = ((uint64_t) float16_val(a))<<54;
    return z;
}

// Assembly:
movq %rdi, %rax
movl %esi, %ecx
andl $0x7e00, %ecx           # imm = 0x7E00
cmpl $0x7c00, %ecx           # imm = 0x7C00
setne %cl
testw $0x1ff, %si             # imm = 0x1FF
sete %dil
orb %cl, %dil
jne 0xc40d
orb $0x1, 0x2(%rdx)
movzwl %si, %ecx
movl %ecx, %edx
shrl $0xf, %edx
movb %dl, (%rax)
andq $0x0, 0x10(%rax)
shlq $0x36, %rcx
movq %rcx, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_float16
float16 float32_to_float16(float32 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;

    a = float32_squash_input_denormal(a, status);

    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );
    if ( aExp == 0xFF ) {
        if (aSig) {
            /* Input is a NaN */
            if (!ieee) {
                float_raise(float_flag_invalid, status);
                return packFloat16(aSign, 0, 0);
            }
            return commonNaNToFloat16(
                float32ToCommonNaN(a, status), status);
        }
        /* Infinity */
        if (!ieee) {
            float_raise(float_flag_invalid, status);
            return packFloat16(aSign, 0x1f, 0x3ff);
        }
        return packFloat16(aSign, 0x1f, 0);
    }
    if (aExp == 0 && aSig == 0) {
        return packFloat16(aSign, 0, 0);
    }
    /* Decimal point between bits 22 and 23. Note that we add the 1 bit
     * even if the input is denormal; however this is harmless because
     * the largest possible single-precision denormal is still smaller
     * than the smallest representable half-precision denormal, and so we
     * will end up ignoring aSig and returning via the "always return zero"
     * codepath.
     */
    aSig |= 0x00800000;
    aExp -= 0x71;

    return roundAndPackFloat16(aSign, aExp, aSig, ieee, status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdx, %rsi
callq 0x91e7
movl %eax, %ecx
movl %eax, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %eax, %esi
shrl $0x17, %esi
movl $0xff, %edi
andl %edi, %esi
shrl $0x1f, %eax
cmpl %edi, %esi
jne 0xc49b
testl %edx, %edx
je 0xc4bc
testb %bpl, %bpl
je 0xc4cb
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ecx, %esi
movq %rbx, %rdx
callq 0xa0a8
movq 0x8(%r14), %rax
shrq $0x36, %rax
movl (%r14), %ecx
shll $0xf, %ecx
testq %rax, %rax
leal 0x7c00(%rcx,%rax), %eax
movl $0xfe00, %ecx           # imm = 0xFE00
cmovel %ecx, %eax
cmpb $0x0, 0x6(%rbx)
cmovnel %ecx, %eax
jmp 0xc4d2
movl %esi, %ecx
orl %edx, %ecx
je 0xc4cf
orl $0x800000, %edx         # imm = 0x800000
addq $-0x71, %rsi
movzbl %al, %edi
movzbl %bpl, %ecx
movq %rbx, %r8
callq 0xc4e9
jmp 0xc4d2
testb %bpl, %bpl
je 0xc4db
shll $0xf, %eax
orl $0x7c00, %eax           # imm = 0x7C00
jmp 0xc4d2
orb $0x1, 0x2(%rbx)
shll $0xf, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
orb $0x1, 0x2(%rbx)
shll $0xf, %eax
orl $0x7fff, %eax           # imm = 0x7FFF
jmp 0xc4d2
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float16_to_float64
float64 float16_to_float64(float16 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;

    aSign = extractFloat16Sign(a);
    aExp = extractFloat16Exp(a);
    aSig = extractFloat16Frac(a);

    if (aExp == 0x1f && ieee) {
        if (aSig) {
            return commonNaNToFloat64(
                float16ToCommonNaN(a, status), status);
        }
        return packFloat64(aSign, 0x7ff, 0);
    }
    if (aExp == 0) {
        if (aSig == 0) {
            return packFloat64(aSign, 0, 0);
        }

        normalizeFloat16Subnormal(aSig, &aExp, &aSig);
        aExp--;
    }
    return packFloat64(aSign, aExp + 0x3f0, ((uint64_t)aSig) << 42);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %edi, %edx
shrl $0xf, %edx
movl %edi, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %edi, %eax
andl $0x3ff, %eax            # imm = 0x3FF
cmpw $0x1f, %cx
setne %r8b
testl %esi, %esi
sete %sil
orb %r8b, %sil
jne 0xc6e4
movabsq $0x7ff0000000000000, %r15 # imm = 0x7FF0000000000000
testl %eax, %eax
je 0xc6ee
movzwl %di, %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xc3e7
movq 0x8(%r14), %rcx
movq %rcx, %rdx
shrq $0xc, %rdx
movl (%r14), %eax
shlq $0x3f, %rax
orq %rdx, %rax
orq %r15, %rax
cmpq $0x1000, %rcx           # imm = 0x1000
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
cmovbq %rcx, %rax
cmpb $0x0, 0x6(%rbx)
cmovneq %rcx, %rax
jmp 0xc736
testw %cx, %cx
je 0xc6f7
movzwl %cx, %ecx
jmp 0xc70e
shlq $0x3f, %rdx
orq %r15, %rdx
jmp 0xc733
testl %eax, %eax
je 0xc72f
bsrl %eax, %esi
xorl $0x1f, %esi
leal -0x15(%rsi), %ecx
shll %cl, %eax
pushq $0x15
popq %rcx
subl %esi, %ecx
movslq %ecx, %rcx
shlq $0x2a, %rax
shlq $0x3f, %rdx
addq %rax, %rdx
shlq $0x34, %rcx
movabsq $0x3f00000000000000, %rax # imm = 0x3F00000000000000
addq %rdx, %rax
addq %rcx, %rax
jmp 0xc736
shlq $0x3f, %rdx
movq %rdx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_float16
float16 float64_to_float16(float64 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig;
    uint32_t zSig;

    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac(a);
    aExp = extractFloat64Exp(a);
    aSign = extractFloat64Sign(a);
    if (aExp == 0x7FF) {
        if (aSig) {
            /* Input is a NaN */
            if (!ieee) {
                float_raise(float_flag_invalid, status);
                return packFloat16(aSign, 0, 0);
            }
            return commonNaNToFloat16(
                float64ToCommonNaN(a, status), status);
        }
        /* Infinity */
        if (!ieee) {
            float_raise(float_flag_invalid, status);
            return packFloat16(aSign, 0x1f, 0x3ff);
        }
        return packFloat16(aSign, 0x1f, 0);
    }
    shift64RightJamming(aSig, 29, &aSig);
    zSig = aSig;
    if (aExp == 0 && zSig == 0) {
        return packFloat16(aSign, 0, 0);
    }
    /* Decimal point between bits 22 and 23. Note that we add the 1 bit
     * even if the input is denormal; however this is harmless because
     * the largest possible single-precision denormal is still smaller
     * than the smallest representable half-precision denormal, and so we
     * will end up ignoring aSig and returning via the "always return zero"
     * codepath.
     */
    zSig |= 0x00800000;
    aExp -= 0x3F1;

    return roundAndPackFloat16(aSign, aExp, zSig, ieee, status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdx, %rsi
callq 0x920d
movq %rax, %rcx
movabsq $0xfffffffffffff, %rdi  # imm = 0xFFFFFFFFFFFFF
andq %rax, %rdi
movq %rax, %rsi
shrq $0x34, %rsi
movl $0x7ff, %edx            # imm = 0x7FF
andq %rdx, %rsi
shrq $0x3f, %rax
cmpq %rdx, %rsi
jne 0xc7c7
testq %rdi, %rdi
je 0xc7fd
testb %bpl, %bpl
je 0xc80c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rcx, %rsi
movq %rbx, %rdx
callq 0xc2e4
movq 0x8(%r14), %rax
shrq $0x36, %rax
movl (%r14), %ecx
shll $0xf, %ecx
testq %rax, %rax
leal 0x7c00(%rcx,%rax), %eax
movl $0xfe00, %ecx           # imm = 0xFE00
cmovel %ecx, %eax
cmpb $0x0, 0x6(%rbx)
cmovnel %ecx, %eax
jmp 0xc813
shrq $0x1d, %rdi
xorl %edx, %edx
shlq $0x23, %rcx
setne %dl
orq %rdi, %rdx
movq %rdx, %rcx
orq %rsi, %rcx
je 0xc810
orl $0x800000, %edx         # imm = 0x800000
addq $-0x3f1, %rsi           # imm = 0xFC0F
movzbl %al, %edi
movzbl %bpl, %ecx
movq %rbx, %r8
callq 0xc4e9
jmp 0xc813
testb %bpl, %bpl
je 0xc81c
shll $0xf, %eax
orl $0x7c00, %eax           # imm = 0x7C00
jmp 0xc813
orb $0x1, 0x2(%rbx)
shll $0xf, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
orb $0x1, 0x2(%rbx)
shll $0xf, %eax
orl $0x7fff, %eax           # imm = 0x7FFF
jmp 0xc813