LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_floatx80
floatx80 float64_to_floatx80(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig;

    a = float64_squash_input_denormal(a, status);
    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp == 0x7FF ) {
        if (aSig) {
            return commonNaNToFloatx80(float64ToCommonNaN(a, status), status);
        }
        return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
    }
    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
        normalizeFloat64Subnormal( aSig, &aExp, &aSig );
    }
    return
        packFloatx80(
            aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
callq 0x920d
movabsq $0xfffffffffffff, %rbx  # imm = 0xFFFFFFFFFFFFF
andq %rax, %rbx
movq %rax, %rsi
shrq $0x34, %rsi
movq %rax, %rdx
shrq $0x3f, %rdx
andq $0x7ff, %rsi            # imm = 0x7FF
je 0xc8b5
cmpl $0x7ff, %esi            # imm = 0x7FF
jne 0xc8d1
testq %rbx, %rbx
je 0xc8f4
movabsq $-0x4000000000000000, %rbx # imm = 0xC000000000000000
movq %rsp, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xc2e4
movw $0xffff, %dx            # imm = 0xFFFF
cmpb $0x0, 0x6(%r14)
jne 0xc8e9
movq 0x8(%rsp), %rax
cmpq $0x2, %rax
jb 0xc8e9
shrq %rax
btsq $0x3f, %rax
movl (%rsp), %edx
shll $0xf, %edx
orl $0x7fff, %edx           # imm = 0x7FFF
movq %rax, %rbx
jmp 0xc8e9
testq %rbx, %rbx
je 0xc90c
bsrq %rbx, %rax
xorl $0x3f, %eax
addl $0xf5, %eax
movzbl %al, %ecx
shlq %cl, %rbx
pushq $0x1
popq %rsi
subl %ecx, %esi
shlq $0xb, %rbx
btsq $0x3f, %rbx
movzwl %dx, %eax
shll $0xf, %eax
leal (%rsi,%rax), %edx
addl $0x3c00, %edx           # imm = 0x3C00
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movzwl %dx, %edx
shll $0xf, %edx
orl $0x7fff, %edx           # imm = 0x7FFF
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
jmp 0xc8e9
movzwl %dx, %edx
shll $0xf, %edx
xorl %ebx, %ebx
jmp 0xc8e9
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_float128
float128 float64_to_float128(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig, zSig0, zSig1;

    a = float64_squash_input_denormal(a, status);
    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp == 0x7FF ) {
        if (aSig) {
            return commonNaNToFloat128(float64ToCommonNaN(a, status), status);
        }
        return packFloat128( aSign, 0x7FFF, 0, 0 );
    }
    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
        normalizeFloat64Subnormal( aSig, &aExp, &aSig );
        --aExp;
    }
    shift128Right( aSig, 0, 4, &zSig0, &zSig1 );
    return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );

}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
callq 0x920d
movq %rax, %rsi
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
andq %rsi, %rax
movq %rsi, %rcx
shrq $0x34, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
andq %rsi, %rdx
andq $0x7ff, %rcx            # imm = 0x7FF
je 0xc97c
cmpl $0x7ff, %ecx            # imm = 0x7FF
jne 0xc999
testq %rax, %rax
je 0xc9c1
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xc2e4
cmpb $0x0, 0x6(%rbx)
je 0xc9d5
movabsq $0x7fff800000000000, %rdx # imm = 0x7FFF800000000000
jmp 0xc9bd
testq %rax, %rax
je 0xc9bd
bsrq %rax, %rcx
xorl $0x3f, %ecx
addl $0xf5, %ecx
movzbl %cl, %ecx
shlq %cl, %rax
negl %ecx
movslq %ecx, %rcx
movq %rax, %rsi
shrq $0x4, %rsi
shlq $0x3c, %rax
shlq $0x30, %rcx
addq %rdx, %rsi
addq %rcx, %rsi
movabsq $0x3c00000000000000, %rdx # imm = 0x3C00000000000000
addq %rsi, %rdx
jmp 0xca00
xorl %eax, %eax
jmp 0xca00
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
orq %rax, %rsi
xorl %eax, %eax
movq %rsi, %rdx
jmp 0xca00
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
shrdq $0x10, %rcx, %rax
shrq $0x10, %rcx
movl 0x8(%rsp), %esi
shlq $0x3f, %rsi
orq %rcx, %rsi
movabsq $0x7fff000000000000, %rdx # imm = 0x7FFF000000000000
orq %rsi, %rdx
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: propagateFloat64NaN
static float64 propagateFloat64NaN(float64 a, float64 b, float_status *status)
{
    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    flag aIsLargerSignificand;
    uint64_t av, bv;

    aIsQuietNaN = float64_is_quiet_nan( a );
    aIsSignalingNaN = float64_is_signaling_nan( a );
    bIsQuietNaN = float64_is_quiet_nan( b );
    bIsSignalingNaN = float64_is_signaling_nan( b );
    av = float64_val(a);
    bv = float64_val(b);

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

    if (status->default_nan_mode)
        return float64_default_nan;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movabsq $0x7ff0000000000000, %r15 # imm = 0x7FF0000000000000
leaq (%rdi,%rdi), %r10
movq %r10, %rdx
shrq $0x34, %rdx
movl $0xfff, %r9d            # imm = 0xFFF
xorl %edi, %edi
cmpl %r9d, %edx
setae %sil
movq %r14, %r12
andq %rax, %r12
cmpq %r15, %r12
sete %dl
movq %r14, %r8
shlq $0xd, %r8
setne %r8b
andb %dl, %r8b
leaq (%rbx,%rbx), %rbp
movq %rbp, %r11
shrq $0x34, %r11
xorl %edx, %edx
cmpl %r9d, %r11d
setae %r9b
movq %rbx, %r13
andq %rax, %r13
cmpq %r15, %r13
sete %r15b
movq %rbx, %r11
shlq $0xd, %r11
setne %r11b
andb %r15b, %r11b
movl %r8d, %r15d
orb %r11b, %r15b
cmpb $0x1, %r15b
jne 0xcc27
orb $0x1, 0x2(%rcx)
cmpb $0x0, 0x6(%rcx)
jne 0xcca5
cmpq %rbp, %r10
jae 0xcc36
xorl %eax, %eax
jmp 0xcc40
movb $0x1, %al
ja 0xcc40
cmpq %rbx, %r14
setb %al
movabsq $0x7ffffffffffff, %rbp  # imm = 0x7FFFFFFFFFFFF
movb %sil, %dil
movzbl %r8b, %esi
movb %r9b, %dl
movzbl %r11b, %ecx
movzbl %al, %r8d
callq 0x1336a
testl %eax, %eax
je 0xcc86
leaq 0x1(%rbp), %rax
orq %rbx, %rax
testq %rbp, %rbx
cmoveq %rbx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %r13
cmovneq %rbx, %rax
jmp 0xcca5
leaq 0x1(%rbp), %rax
orq %r14, %rax
testq %rbp, %r14
cmoveq %r14, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %r12
cmovneq %r14, %rax
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_trunc_to_int
float64 float64_trunc_to_int(float64 a, float_status *status)
{
    int oldmode;
    float64 res;
    oldmode = status->float_rounding_mode;
    status->float_rounding_mode = float_round_to_zero;
    res = float64_round_to_int(a, status);
    status->float_rounding_mode = oldmode;
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x1(%rsi), %bpl
movb $0x3, 0x1(%rsi)
callq 0xca06
movb %bpl, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: mul64To128
static inline void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr )
{
    uint32_t aHigh, aLow, bHigh, bLow;
    uint64_t z0, zMiddleA, zMiddleB, z1;

    aLow = a;
    aHigh = a>>32;
    bLow = b;
    bHigh = b>>32;
    z1 = ( (uint64_t) aLow ) * bLow;
    zMiddleA = ( (uint64_t) aLow ) * bHigh;
    zMiddleB = ( (uint64_t) aHigh ) * bLow;
    z0 = ( (uint64_t) aHigh ) * bHigh;
    zMiddleA += zMiddleB;
    z0 += ( ( (uint64_t) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );
    zMiddleA <<= 32;
    z1 += zMiddleA;
    z0 += ( z1 < zMiddleA );
    *z1Ptr = z1;
    *z0Ptr = z0;

}

// Assembly:
movq %rdi, %rax
shrq $0x20, %rax
movq %rsi, %r8
shrq $0x20, %r8
movl %edi, %r9d
movl %esi, %r10d
imulq %r8, %r9
imulq %rax, %r10
imulq %rax, %r8
xorl %eax, %eax
addq %r9, %r10
setb %al
shlq $0x20, %rax
movq %r10, %r9
shrq $0x20, %r9
addq %r8, %r9
shlq $0x20, %r10
imulq %rdi, %rsi
cmpq %r10, %rsi
adcq %rax, %r9
movq %rsi, (%rcx)
movq %r9, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift128RightJamming
static inline void
 shift128RightJamming(
     uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
{
    uint64_t z0, z1;
    int8 negCount = ( - count ) & 63;

    if ( count == 0 ) {
        z1 = a1;
        z0 = a0;
    }
    else if ( count < 64 ) {
        z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 );
        z0 = a0>>count;
    }
    else {
        if ( count == 64 ) {
            z1 = a0 | ( a1 != 0 );
        }
        else if ( count < 128 ) {
            z1 = ( a0>>( count & 63 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 );
        }
        else {
            z1 = ( ( a0 | a1 ) != 0 );
        }
        z0 = 0;
    }
    *z1Ptr = z1;
    *z0Ptr = z0;

}

// Assembly:
movq %rcx, %rax
testq %rdx, %rdx
je 0xdcdd
movl %edx, %r9d
negb %r9b
andb $0x3f, %r9b
cmpq $0x3f, %rdx
jg 0xdc9c
movq %rdi, %r10
movl %r9d, %ecx
shlq %cl, %r10
movq %rsi, %r11
movl %edx, %ecx
shrq %cl, %r11
orq %r10, %r11
movl %r9d, %ecx
shlq %cl, %rsi
xorl %r9d, %r9d
testq %rsi, %rsi
setne %r9b
orq %r11, %r9
movl %edx, %ecx
shrq %cl, %rdi
movq %r9, %rsi
jmp 0xdcdd
cmpq $0x40, %rdx
jne 0xdcaf
xorl %ecx, %ecx
testq %rsi, %rsi
setne %cl
orq %rdi, %rcx
jmp 0xdcd8
cmpq $0x7f, %rdx
ja 0xdcd0
movq %rdi, %r10
movl %edx, %ecx
shrq %cl, %r10
movl %r9d, %ecx
shlq %cl, %rdi
xorl %ecx, %ecx
orq %rsi, %rdi
setne %cl
orq %r10, %rcx
jmp 0xdcd8
xorl %ecx, %ecx
orq %rdi, %rsi
setne %cl
xorl %edi, %edi
movq %rcx, %rsi
movq %rsi, (%r8)
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_log2
float64 float64_log2(float64 a, float_status *status)
{
    flag aSign, zSign;
    int_fast16_t aExp;
    uint64_t aSig, aSig0, aSig1, zSig, i;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );

    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloat64( 1, 0x7FF, 0 );
        normalizeFloat64Subnormal( aSig, &aExp, &aSig );
    }
    if ( aSign ) {
        float_raise(float_flag_invalid, status);
        return float64_default_nan;
    }
    if ( aExp == 0x7FF ) {
        if (aSig) {
            return propagateFloat64NaN(a, float64_zero, status);
        }
        return a;
    }

    aExp -= 0x3FF;
    aSig |= LIT64( 0x0010000000000000 );
    zSign = aExp < 0;
    zSig = (uint64_t)aExp << 52;
    for (i = 1LL << 51; i > 0; i >>= 1) {
        mul64To128( aSig, aSig, &aSig0, &aSig1 );
        aSig = ( aSig0 << 12 ) | ( aSig1 >> 52 );
        if ( aSig & LIT64( 0x0020000000000000 ) ) {
            aSig >>= 1;
            zSig |= i;
        }
    }

    if ( zSign )
        zSig = -zSig;
    return normalizeRoundAndPackFloat64(zSign, 0x408, zSig, status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movabsq $0xfffffffffffff, %r14  # imm = 0xFFFFFFFFFFFFF
callq 0x920d
movq %rax, %rdi
andq %r14, %rdi
movq %rax, %r12
shrq $0x34, %r12
andq $0x7ff, %r12            # imm = 0x7FF
jne 0xded8
testq %rdi, %rdi
je 0xdfc2
bsrq %rdi, %rcx
xorl $0x3f, %ecx
addl $0xf5, %ecx
movzbl %cl, %ecx
shlq %cl, %rdi
pushq $0x1
popq %rdx
subl %ecx, %edx
movslq %edx, %r12
testq %rax, %rax
js 0xdf0a
cmpq $0x7ff, %r12            # imm = 0x7FF
jne 0xdf1d
testq %rdi, %rdi
je 0xdfcc
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcb8c
orb $0x1, 0x2(%rbx)
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
jmp 0xdfcc
incq %r14
orq %r14, %rdi
movq %r12, %rax
shlq $0x34, %rax
movabsq $-0x3ff0000000000000, %r13 # imm = 0xC010000000000000
addq %rax, %r13
movabsq $0x8000000000000, %rbp  # imm = 0x8000000000000
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
testq %rbp, %rbp
je 0xdf90
movq %rdi, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xd0a6
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdi
shrdq $0x34, %rax, %rdi
movq %rdi, %rax
shlq $0xa, %rax
movq %rdi, %rcx
shrq $0x35, %rcx
andb $0x1, %cl
shrq %cl, %rdi
sarq $0x3f, %rax
andq %rbp, %rax
orq %rax, %r13
shrq %rbp
jmp 0xdf4b
movq %r13, %rdx
negq %rdx
xorl %edi, %edi
cmpq $0x3ff, %r12            # imm = 0x3FF
setl %dil
cmovgeq %r13, %rdx
movl $0x408, %esi            # imm = 0x408
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9591
movabsq $-0x10000000000000, %rax # imm = 0xFFF0000000000000
addq $0x18, %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_eq
int float64_eq(float64 a, float64 b, float_status *status)
{
    uint64_t av, bv;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    av = float64_val(a);
    bv = float64_val(b);
    return ( av == bv ) || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movabsq $0x7ff0000000000000, %r12 # imm = 0x7FF0000000000000
movq %rdx, %rsi
callq 0x920d
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x920d
movq %r14, %rcx
notq %rcx
testq %r12, %rcx
sete %cl
movq %r14, %rdx
shlq $0xc, %rdx
setne %dl
testb %dl, %cl
jne 0xe05c
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq %rax, %rdx
notq %rdx
testq %rdx, %r12
setne %dl
testq %rcx, %rax
sete %cl
orb %dl, %cl
je 0xe05c
cmpq %rax, %r14
sete %cl
orq %r14, %rax
shlq %rax
testq %rax, %rax
sete %al
orb %cl, %al
movzbl %al, %eax
jmp 0xe062
orb $0x1, 0x2(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_le
int float64_le(float64 a, float64 b, float_status *status)
{
    flag aSign, bSign;
    uint64_t av, bv;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    aSign = extractFloat64Sign( a );
    bSign = extractFloat64Sign( b );
    av = float64_val(a);
    bv = float64_val(b);
    if ( aSign != bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );
    return ( av == bv ) || ( aSign ^ ( av < bv ) );

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movabsq $0x7ff0000000000000, %r12 # imm = 0x7FF0000000000000
movq %rdx, %rsi
callq 0x920d
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x920d
movq %rbx, %rcx
notq %rcx
testq %r12, %rcx
sete %cl
movq %rbx, %rdx
shlq $0xc, %rdx
setne %dl
testb %dl, %cl
jne 0xe0f1
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq %rax, %rdx
notq %rdx
testq %rdx, %r12
setne %dl
testq %rcx, %rax
sete %cl
orb %dl, %cl
je 0xe0f1
movq %rax, %rcx
xorq %rbx, %rcx
js 0xe0fa
cmpq %rax, %rbx
sete %cl
setb %dl
testq %rbx, %rbx
sets %al
xorb %dl, %al
jmp 0xe10c
orb $0x1, 0x2(%r14)
xorl %eax, %eax
jmp 0xe10e
testq %rbx, %rbx
sets %cl
orq %rbx, %rax
shlq %rax
testq %rax, %rax
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_unordered
int float64_unordered(float64 a, float64 b, float_status *status)
{
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movabsq $0x7ff0000000000000, %r12 # imm = 0x7FF0000000000000
movq %rdx, %rsi
callq 0x920d
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x920d
movq %r15, %rcx
notq %rcx
testq %r12, %rcx
sete %cl
shlq $0xc, %r15
setne %dl
testb %dl, %cl
jne 0xe233
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq %rax, %rdx
notq %rdx
testq %rdx, %r12
setne %dl
testq %rcx, %rax
sete %cl
xorl %eax, %eax
orb %dl, %cl
jne 0xe23a
orb $0x1, 0x2(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_unordered_quiet
int float64_unordered_quiet(float64 a, float64 b, float_status *status)
{
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
       ) {
        if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 1;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movabsq $0x7ff0000000000000, %r12 # imm = 0x7FF0000000000000
movq %rdx, %rsi
callq 0x920d
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x920d
movq %r14, %rcx
notq %rcx
testq %r12, %rcx
sete %cl
movq %r14, %rdx
shlq $0xc, %rdx
setne %dl
testb %dl, %cl
jne 0xe563
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq %rax, %rdx
notq %rdx
testq %rdx, %r12
setne %dl
testq %rcx, %rax
sete %sil
xorl %ecx, %ecx
orb %dl, %sil
jne 0xe5ab
movabsq $0x7ff8000000000000, %rdx # imm = 0x7FF8000000000000
movq %r14, %rcx
andq %rdx, %rcx
cmpq %r12, %rcx
sete %sil
shlq $0xd, %r14
setne %dil
pushq $0x1
popq %rcx
testb %dil, %sil
jne 0xe5a7
movabsq $0x7ffffffffffff, %rsi  # imm = 0x7FFFFFFFFFFFF
andq %rax, %rdx
cmpq %r12, %rdx
setne %dl
testq %rsi, %rax
sete %al
orb %dl, %al
jne 0xe5ab
orb $0x1, 0x2(%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int32
int32 floatx80_to_int32(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
    shiftCount = 0x4037 - aExp;
    if ( shiftCount <= 0 ) shiftCount = 1;
    shift64RightJamming( aSig, shiftCount, &aSig );
    return roundAndPackInt32(aSign, aSig, status);

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movl %esi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movl %esi, %ecx
shrl $0xf, %ecx
andl $0x1, %ecx
notl %esi
leaq (,%rdi,2), %rdx
xorl %ebp, %ebp
testq %rdx, %rdx
cmovel %ecx, %ebp
testw $0x7fff, %si            # imm = 0x7FFF
cmovnel %ecx, %ebp
movl $0x4037, %ecx           # imm = 0x4037
subl %eax, %ecx
cmpl $0x2, %ecx
pushq $0x1
popq %rsi
cmovgel %ecx, %esi
movq %r14, %rdx
callq 0x93e7
movq (%r14), %rsi
movl %ebp, %edi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9a4b
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int32_round_to_zero
int32 floatx80_to_int32_round_to_zero(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig, savedASig;
    int32_t z;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    if ( 0x401E < aExp ) {
        if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
        goto invalid;
    }
    else if ( aExp < 0x3FFF ) {
        if (aExp || aSig) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    shiftCount = 0x403E - 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:
movzwl %si, %r8d
movl %esi, %r9d
andl $0x7fff, %r9d           # imm = 0x7FFF
shrl $0xf, %r8d
cmpw $0x401f, %r9w           # imm = 0x401F
jb 0xe669
shlq %rdi
movzbl %r8b, %eax
xorl %r8d, %r8d
testq %rdi, %rdi
cmovel %eax, %r8d
cmpl $0x7fff, %r9d           # imm = 0x7FFF
cmovnel %eax, %r8d
orb $0x1, 0x2(%rdx)
cmpb $0x1, %r8b
movl $0x80000000, %eax       # imm = 0x80000000
sbbl $0x0, %eax
retq
cmpw $0x3ffe, %r9w           # imm = 0x3FFE
ja 0xe67d
xorl %eax, %eax
orq %rdi, %r9
je 0xe67c
orb $0x20, 0x2(%rdx)
retq
movl $0x403e, %ecx           # imm = 0x403E
subl %r9d, %ecx
movq %rdi, %r9
shrq %cl, %r9
movl %r9d, %eax
negl %eax
testw %si, %si
cmovnsl %r9d, %eax
movl %eax, %esi
shrl $0x1f, %esi
movzwl %r8w, %r10d
cmpl %r10d, %esi
jne 0xe658
shlq %cl, %r9
cmpq %rdi, %r9
jne 0xe678
jmp 0xe67c
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int64
int64 floatx80_to_int64(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig, aSigExtra;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    shiftCount = 0x403E - aExp;
    if ( shiftCount <= 0 ) {
        if ( shiftCount ) {
            float_raise(float_flag_invalid, status);
            if (    ! aSign
                 || (    ( aExp == 0x7FFF )
                      && ( aSig != LIT64( 0x8000000000000000 ) ) )
               ) {
                return LIT64( 0x7FFFFFFFFFFFFFFF );
            }
            return (int64_t) LIT64( 0x8000000000000000 );
        }
        aSigExtra = 0;
    }
    else {
        shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
    }
    return roundAndPackInt64(aSign, aSig, aSigExtra, status);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
movq %rdi, 0x8(%rsp)
movl %ebp, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
cmpw $0x403e, %cx            # imm = 0x403E
jb 0xe6db
jne 0xe721
xorl %edx, %edx
jmp 0xe706
movzwl %cx, %eax
movl $0x403e, %edx           # imm = 0x403E
subq %rax, %rdx
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rsi, %rdi
xorl %esi, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x9cb8
movq (%r14), %rsi
movq (%r15), %rdx
movzwl %bp, %eax
shrl $0xf, %eax
movzbl %al, %edi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9d0f
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%rbx)
testw %bp, %bp
jns 0xe748
leaq 0x1(%rax), %rdx
cmpq %rdx, %rsi
cmoveq %rdx, %rax
cmpw $0x7fff, %cx            # imm = 0x7FFF
cmovneq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int64_round_to_zero
int64 floatx80_to_int64_round_to_zero(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig;
    int64 z;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    shiftCount = aExp - 0x403E;
    if ( 0 <= shiftCount ) {
        aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );
        if ( ( a.high != 0xC03E ) || aSig ) {
            float_raise(float_flag_invalid, status);
            if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
                return LIT64( 0x7FFFFFFFFFFFFFFF );
            }
        }
        return (int64_t) LIT64( 0x8000000000000000 );
    }
    else if ( aExp < 0x3FFF ) {
        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:
movl %esi, %r8d
andl $0x7fff, %r8d           # imm = 0x7FFF
cmpw $0x403e, %r8w           # imm = 0x403E
jb 0xe7b0
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpw $0xc03e, %si            # imm = 0xC03E
setne %cl
leaq (,%rdi,2), %r9
testq %r9, %r9
setne %r9b
orb %cl, %r9b
cmpb $0x1, %r9b
jne 0xe7ac
testq %rax, %rdi
setne %cl
orb $0x1, 0x2(%rdx)
cmpl $0x7fff, %r8d           # imm = 0x7FFF
sete %dl
testw %si, %si
jns 0xe7f1
andb %cl, %dl
jne 0xe7f1
incq %rax
retq
cmpw $0x3ffe, %r8w           # imm = 0x3FFE
ja 0xe7c7
movl %r8d, %eax
orq %rdi, %rax
je 0xe7c4
orb $0x20, 0x2(%rdx)
xorl %eax, %eax
retq
leal 0x2(%r8), %eax
movb $0x3e, %cl
subb %r8b, %cl
movq %rdi, %r8
shrq %cl, %r8
movl %eax, %ecx
shlq %cl, %rdi
testq %rdi, %rdi
je 0xe7e4
orb $0x20, 0x2(%rdx)
movq %r8, %rax
negq %rax
testw %si, %si
cmovnsq %r8, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_float32
float32 floatx80_to_float32(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp;
    uint64_t aSig;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    if ( aExp == 0x7FFF ) {
        if ( (uint64_t) ( aSig<<1 ) ) {
            return commonNaNToFloat32(floatx80ToCommonNaN(a, status), status);
        }
        return packFloat32( aSign, 0xFF, 0 );
    }
    shift64RightJamming( aSig, 33, &aSig );
    if ( aExp || aSig ) aExp -= 0x3F81;
    return roundAndPackFloat32(aSign, aExp, aSig, status);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
movzwl %dx, %eax
movl %edx, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
shrl $0xf, %eax
cmpw $0x7fff, %cx            # imm = 0x7FFF
jne 0xe85a
leaq (,%rsi,2), %rcx
testq %rcx, %rcx
je 0xe89a
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rcx
callq 0xe8aa
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 0xe8a2
movzwl %cx, %edi
movq %rsi, %r8
shrq $0x21, %r8
xorl %edx, %edx
shlq $0x1f, %rsi
setne %dl
orq %r8, %rdx
addq $-0x3f81, %rdi          # imm = 0xC07F
testq %rdx, %rdx
movq %rdi, %rsi
cmoveq %rdx, %rsi
testw %cx, %cx
cmovneq %rdi, %rsi
movzwl %ax, %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-specialize.h
// Function: floatx80ToCommonNaN
static commonNaNT floatx80ToCommonNaN(floatx80 a, float_status *status)
{
    commonNaNT z;

    if (floatx80_is_signaling_nan(a)) {
        float_raise(float_flag_invalid, status);
    }
    if ( a.low >> 63 ) {
        z.sign = a.high >> 15;
        z.low = 0;
        z.high = a.low << 1;
    } else {
        z.sign = floatx80_default_nan_high >> 15;
        z.low = 0;
        z.high = floatx80_default_nan_low << 1;
    }
    return z;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x90e5
testl %eax, %eax
je 0xe8cf
orb $0x1, 0x2(%r15)
movzwl %bp, %eax
shrl $0xf, %eax
testq %r14, %r14
pushq $0x1
popq %rcx
cmovsl %eax, %ecx
leaq (%r14,%r14), %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
cmovsq %rax, %rdx
movb %cl, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rdx, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_float64
float64 floatx80_to_float64(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp;
    uint64_t aSig, zSig;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    if ( aExp == 0x7FFF ) {
        if ( (uint64_t) ( aSig<<1 ) ) {
            return commonNaNToFloat64(floatx80ToCommonNaN(a, status), status);
        }
        return packFloat64( aSign, 0x7FF, 0 );
    }
    shift64RightJamming( aSig, 1, &zSig );
    if ( aExp || aSig ) aExp -= 0x3C01;
    return roundAndPackFloat64(aSign, aExp, zSig, status);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
movzwl %dx, %eax
movl %edx, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
shrl $0xf, %eax
cmpw $0x7fff, %cx            # imm = 0x7FFF
jne 0xe991
movabsq $0x7ff0000000000000, %r15 # imm = 0x7FF0000000000000
leaq (,%rsi,2), %rcx
testq %rcx, %rcx
je 0xe9cb
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rcx
callq 0xe8aa
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 0xe9d5
movzwl %cx, %edi
movq %rsi, %r8
shrq %r8
movl %esi, %edx
andl $0x1, %edx
orq %r8, %rdx
addq $-0x3c01, %rdi          # imm = 0xC3FF
testq %rsi, %rsi
cmovneq %rdi, %rsi
testw %cx, %cx
cmovneq %rdi, %rsi
movzwl %ax, %edi
movq %rbx, %rcx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x973e
movzwl %ax, %eax
shlq $0x3f, %rax
orq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_float128
float128 floatx80_to_float128(floatx80 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig, zSig0, zSig1;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) {
        return commonNaNToFloat128(floatx80ToCommonNaN(a, status), status);
    }
    shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );
    return packFloat128( aSign, aExp, zSig0, zSig1 );

}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %ecx
movq %rdi, %rax
movl %esi, %edx
andl $0x7fff, %edx           # imm = 0x7FFF
cmpw $0x7fff, %dx            # imm = 0x7FFF
setne %sil
leaq (,%rdi,2), %rdi
testq %rdi, %rdi
sete %dil
orb %sil, %dil
je 0xea3f
shrl $0xf, %ecx
movq %rax, %rsi
shrq $0xf, %rsi
movabsq $0xffffffffffff, %rdi   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rdi
shlq $0x31, %rax
shlq $0x3f, %rcx
orq %rdi, %rcx
movzwl %dx, %edx
shlq $0x30, %rdx
orq %rcx, %rdx
jmp 0xea90
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movl %ecx, %edx
movq %rbx, %rcx
callq 0xe8aa
cmpb $0x0, 0x6(%rbx)
je 0xea65
movabsq $0x7fff800000000000, %rdx # imm = 0x7FFF800000000000
xorl %eax, %eax
jmp 0xea90
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
shrdq $0x10, %rcx, %rax
shrq $0x10, %rcx
movl 0x8(%rsp), %esi
shlq $0x3f, %rsi
orq %rcx, %rsi
movabsq $0x7fff000000000000, %rdx # imm = 0x7FFF000000000000
orq %rsi, %rdx
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: propagateFloatx80NaN
static floatx80 propagateFloatx80NaN(floatx80 a, floatx80 b,
                                     float_status *status)
{
    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    flag aIsLargerSignificand;

    aIsQuietNaN = floatx80_is_quiet_nan( a );
    aIsSignalingNaN = floatx80_is_signaling_nan( a );
    bIsQuietNaN = floatx80_is_quiet_nan( b );
    bIsSignalingNaN = floatx80_is_signaling_nan( b );

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

    if (status->default_nan_mode) {
        a.low = floatx80_default_nan_low;
        a.high = floatx80_default_nan_high;
        return a;
    }

    if (a.low < b.low) {
        aIsLargerSignificand = 0;
    } else if (b.low < a.low) {
        aIsLargerSignificand = 1;
    } else {
        aIsLargerSignificand = (a.high < b.high) ? 1 : 0;
    }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %ebp
movl %esi, %eax
notl %eax
testw $0x7fff, %ax            # imm = 0x7FFF
sete 0xf(%rsp)
movq %rdi, 0x10(%rsp)
callq 0x90e5
movl %eax, %r12d
movl %ebx, %eax
notl %eax
testw $0x7fff, %ax            # imm = 0x7FFF
sete 0xe(%rsp)
movq %r15, %r14
movq %r15, %rdi
movl %ebx, %esi
callq 0x90e5
movl %eax, %ecx
orl %r12d, %ecx
je 0xecab
orb $0x1, 0x2(%r13)
cmpb $0x0, 0x6(%r13)
je 0xecc2
movw $0xffff, %dx            # imm = 0xFFFF
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
jmp 0xed30
movq 0x10(%rsp), %r13
movq %r13, %rcx
shrq $0x3e, %rcx
movq %r14, %rdx
shrq $0x3e, %rdx
andl $0x1, %ecx
andl $0x1, %edx
movb 0xf(%rsp), %sil
andb %cl, %sil
movl %esi, %ecx
movb 0xe(%rsp), %sil
andb %dl, %sil
movl %esi, %edx
cmpq %r14, %r13
jae 0xecf9
xorl %r8d, %r8d
jmp 0xed05
movb $0x1, %r8b
ja 0xed05
cmpw %bx, %bp
setb %r8b
movzbl %cl, %edi
movzbl %r12b, %esi
movzbl %dl, %edx
movzbl %al, %ecx
movzbl %r8b, %r8d
callq 0x1336a
testl %eax, %eax
je 0xed26
movq %r14, %rdi
movl %ebx, %esi
jmp 0xed2b
movq %r13, %rdi
movl %ebp, %esi
callq 0x9118
addq $0x18, %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: floatx80_add
floatx80 floatx80_add(floatx80 a, floatx80 b, float_status *status)
{
    flag aSign, bSign;

    aSign = extractFloatx80Sign( a );
    bSign = extractFloatx80Sign( b );
    if ( aSign == bSign ) {
        return addFloatx80Sigs(a, b, aSign, status);
    }
    else {
        return subFloatx80Sigs(a, b, aSign, status);
    }

}

// Assembly:
movq %r8, %r9
movl $0xffff, %eax           # imm = 0xFFFF
movl %ecx, %r8d
andl %eax, %r8d
andl %esi, %eax
shrl $0xf, %eax
shrl $0xf, %r8d
cmpw %r8w, %ax
jne 0xed62
movzbl %al, %r8d
jmp 0xed6b
movzbl %al, %r8d
jmp 0xeefc
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: normalizeRoundAndPackFloatx80
static floatx80 normalizeRoundAndPackFloatx80(int8 roundingPrecision,
                                              flag zSign, int32 zExp,
                                              uint64_t zSig0, uint64_t zSig1,
                                              float_status *status)
{
    int8 shiftCount;

    if ( zSig0 == 0 ) {
        zSig0 = zSig1;
        zSig1 = 0;
        zExp -= 64;
    }
    shiftCount = countLeadingZeros64( zSig0 );
    shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
    zExp -= shiftCount;
    return roundAndPackFloatx80(roundingPrecision, zSign, zExp,
                                zSig0, zSig1, status);

}

// Assembly:
movq %rcx, %r10
testq %rcx, %rcx
movq %rcx, %rax
cmoveq %r8, %rax
cmoveq %rcx, %r8
testq %rax, %rax
je 0xfb30
bsrq %rax, %r11
xorq $0x3f, %r11
jmp 0xfb3a
movabsq $0x40, %r11
testq %r11, %r11
je 0xfb52
pushq %rbx
movl %r11d, %ecx
shlq %cl, %rax
negb %cl
movq %r8, %rbx
shrq %cl, %rbx
orq %rbx, %rax
popq %rbx
movl %r11d, %ecx
shlq %cl, %r8
leal -0x40(%rdx), %ecx
testq %r10, %r10
cmovnel %edx, %ecx
subl %r11d, %ecx
movsbl %dil, %edi
movzbl %sil, %esi
movl %ecx, %edx
movq %rax, %rcx
jmp 0xf265
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_eq
int floatx80_eq(floatx80 a, floatx80 b, float_status *status)
{

    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
         || (    ( extractFloatx80Exp( b ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    return
           ( a.low == b.low )
        && (    ( a.high == b.high )
             || (    ( a.low == 0 )
                  && ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) )
           );

}

// Assembly:
movl %esi, %eax
notl %eax
testw $0x7fff, %ax            # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %r9
testq %r9, %r9
sete %r9b
orb %al, %r9b
cmpb $0x1, %r9b
jne 0xfe4a
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r9d
notl %r9d
testw $0x7fff, %r9w           # imm = 0x7FFF
setne %r9b
testq %rax, %rdx
sete %al
orb %r9b, %al
je 0xfe4a
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0xfe63
cmpw %cx, %si
jne 0xfe52
pushq $0x1
popq %rax
retq
orb $0x1, 0x2(%r8)
xorl %eax, %eax
retq
testq %rdi, %rdi
jne 0xfe63
orl %esi, %ecx
xorl %eax, %eax
testw $0x7fff, %cx            # imm = 0x7FFF
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_le
int floatx80_le(floatx80 a, floatx80 b, float_status *status)
{
    flag aSign, bSign;

    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
         || (    ( extractFloatx80Exp( b ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    aSign = extractFloatx80Sign( a );
    bSign = extractFloatx80Sign( b );
    if ( aSign != bSign ) {
        return
               aSign
            || (    ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                 == 0 );
    }
    return
          aSign ? le128( b.high, b.low, a.high, a.low )
        : le128( a.high, a.low, b.high, b.low );

}

// Assembly:
movl %esi, %eax
notl %eax
testw $0x7fff, %ax            # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %r9
testq %r9, %r9
sete %r9b
orb %al, %r9b
cmpb $0x1, %r9b
jne 0xfec7
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r9d
notl %r9d
testw $0x7fff, %r9w           # imm = 0x7FFF
setne %r9b
testq %rax, %rdx
sete %al
orb %r9b, %al
je 0xfec7
movl %ecx, %eax
xorw %si, %ax
js 0xfed2
testw %si, %si
js 0xfee9
cmpw %cx, %si
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0xfef6
orb $0x1, 0x2(%r8)
xorl %eax, %eax
movzbl %al, %eax
retq
testw %si, %si
js 0xff00
orl %esi, %ecx
addl %ecx, %ecx
movzwl %cx, %eax
orq %rdi, %rax
orq %rdx, %rax
sete %al
jmp 0xfece
cmpw %si, %cx
setb %cl
sete %sil
cmpq %rdi, %rdx
setbe %al
andb %sil, %al
orb %cl, %al
jmp 0xfece
movb $0x1, %al
jmp 0xfece
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_lt
int floatx80_lt(floatx80 a, floatx80 b, float_status *status)
{
    flag aSign, bSign;

    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
         || (    ( extractFloatx80Exp( b ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    aSign = extractFloatx80Sign( a );
    bSign = extractFloatx80Sign( b );
    if ( aSign != bSign ) {
        return
               aSign
            && (    ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                 != 0 );
    }
    return
          aSign ? lt128( b.high, b.low, a.high, a.low )
        : lt128( a.high, a.low, b.high, b.low );

}

// Assembly:
movl %esi, %eax
notl %eax
testw $0x7fff, %ax            # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %r9
testq %r9, %r9
sete %r9b
orb %al, %r9b
cmpb $0x1, %r9b
jne 0xff67
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r9d
notl %r9d
testw $0x7fff, %r9w           # imm = 0x7FFF
setne %r9b
testq %rax, %rdx
sete %al
orb %r9b, %al
je 0xff67
movl %ecx, %eax
xorw %si, %ax
js 0xff72
testw %si, %si
js 0xff89
cmpw %cx, %si
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0xff96
orb $0x1, 0x2(%r8)
xorl %eax, %eax
movzbl %al, %eax
retq
testw %si, %si
jns 0xff6c
orl %esi, %ecx
addl %ecx, %ecx
movzwl %cx, %eax
orq %rdi, %rax
orq %rdx, %rax
setne %al
jmp 0xff6e
cmpw %si, %cx
setb %cl
sete %sil
cmpq %rdi, %rdx
setb %al
andb %sil, %al
orb %cl, %al
jmp 0xff6e
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_unordered
int floatx80_unordered(floatx80 a, floatx80 b, float_status *status)
{
    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
         || (    ( extractFloatx80Exp( b ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 1;
    }
    return 0;
}

// Assembly:
notl %esi
testw $0x7fff, %si            # imm = 0x7FFF
setne %al
shlq %rdi
testq %rdi, %rdi
sete %sil
orb %al, %sil
cmpb $0x1, %sil
jne 0xffdd
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
notl %ecx
testw $0x7fff, %cx            # imm = 0x7FFF
setne %cl
testq %rax, %rdx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0xffe5
orb $0x1, 0x2(%r8)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_eq_quiet
int floatx80_eq_quiet(floatx80 a, floatx80 b, float_status *status)
{

    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
         || (    ( extractFloatx80Exp( b ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
       ) {
        if (    floatx80_is_signaling_nan( a )
             || floatx80_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 0;
    }
    return
           ( a.low == b.low )
        && (    ( a.high == b.high )
             || (    ( a.low == 0 )
                  && ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) )
           );

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %eax
notl %eax
testw $0x7fff, %ax            # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %rcx
testq %rcx, %rcx
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x10044
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ebx, %ecx
notl %ecx
testw $0x7fff, %cx            # imm = 0x7FFF
setne %cl
testq %rax, %r15
sete %al
orb %cl, %al
je 0x10044
xorl %eax, %eax
cmpq %r15, %rdi
jne 0x10062
cmpw %bx, %si
jne 0x10068
pushq $0x1
popq %rax
jmp 0x10062
callq 0x90e5
testl %eax, %eax
jne 0x1005b
movq %r15, %rdi
movl %ebx, %esi
callq 0x90e5
testl %eax, %eax
je 0x10060
orb $0x1, 0x2(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
testq %rdi, %rdi
jne 0x10062
orl %esi, %ebx
xorl %eax, %eax
testw $0x7fff, %bx            # imm = 0x7FFF
sete %al
jmp 0x10062
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_lt_quiet
int floatx80_lt_quiet(floatx80 a, floatx80 b, float_status *status)
{
    flag aSign, bSign;

    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
         || (    ( extractFloatx80Exp( b ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
       ) {
        if (    floatx80_is_signaling_nan( a )
             || floatx80_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 0;
    }
    aSign = extractFloatx80Sign( a );
    bSign = extractFloatx80Sign( b );
    if ( aSign != bSign ) {
        return
               aSign
            && (    ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
                 != 0 );
    }
    return
          aSign ? lt128( b.high, b.low, a.high, a.low )
        : lt128( a.high, a.low, b.high, b.low );

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %rbx
movl %esi, %eax
notl %eax
testw $0x7fff, %ax            # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %rcx
testq %rcx, %rcx
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1019d
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ebp, %ecx
notl %ecx
testw $0x7fff, %cx            # imm = 0x7FFF
setne %cl
testq %rax, %rbx
sete %al
orb %cl, %al
je 0x1019d
movl %ebp, %eax
xorw %si, %ax
js 0x101c3
testw %si, %si
js 0x101da
cmpw %bp, %si
setb %cl
sete %dl
cmpq %rbx, %rdi
jmp 0x101e6
callq 0x90e5
testl %eax, %eax
jne 0x101b4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x90e5
testl %eax, %eax
je 0x101b9
orb $0x1, 0x2(%r14)
xorl %eax, %eax
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
testw %si, %si
jns 0x101b9
orl %esi, %ebp
addl %ebp, %ebp
movzwl %bp, %eax
orq %rdi, %rax
orq %rbx, %rax
setne %al
jmp 0x101bb
cmpw %si, %bp
setb %cl
sete %dl
cmpq %rdi, %rbx
setb %al
andb %dl, %al
orb %cl, %al
jmp 0x101bb
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_unordered_quiet
int floatx80_unordered_quiet(floatx80 a, floatx80 b, float_status *status)
{
    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
         || (    ( extractFloatx80Exp( b ) == 0x7FFF )
              && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
       ) {
        if (    floatx80_is_signaling_nan( a )
             || floatx80_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %eax
notl %eax
testw $0x7fff, %ax            # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %rcx
testq %rcx, %rcx
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x10241
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ebp, %ecx
notl %ecx
testw $0x7fff, %cx            # imm = 0x7FFF
setne %cl
testq %rax, %r14
sete %al
xorl %r15d, %r15d
orb %cl, %al
jne 0x10260
callq 0x90e5
pushq $0x1
popq %r15
testl %eax, %eax
jne 0x1025c
movq %r14, %rdi
movl %ebp, %esi
callq 0x90e5
testl %eax, %eax
je 0x10260
orb $0x1, 0x2(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq