LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1004d
movzbl %al, %r8d
jmp 0x10056
movzbl %al, %r8d
jmp 0x1022d
// File: /workspace/github_c_makefile_star2_O1/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 0x11075
bsrq %rax, %r11
xorq $0x3f, %r11
jmp 0x1107b
movl $0x40, %r11d
testq %r11, %r11
je 0x11093
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 0x1060d
// File: /workspace/github_c_makefile_star2_O1/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
testl $0x7fff, %eax           # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %r9
testq %r9, %r9
sete %r9b
orb %al, %r9b
cmpb $0x1, %r9b
jne 0x113e1
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r9d
notl %r9d
testl $0x7fff, %r9d           # imm = 0x7FFF
setne %r9b
testq %rax, %rdx
sete %al
orb %r9b, %al
je 0x113e1
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0x113e0
movl $0x1, %eax
cmpw %cx, %si
je 0x113e0
movl $0x0, %eax
testq %rdi, %rdi
jne 0x113e0
orl %esi, %ecx
xorl %eax, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
sete %al
retq
orb $0x1, 0x2(%r8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
testl $0x7fff, %eax           # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %r9
testq %r9, %r9
sete %r9b
orb %al, %r9b
cmpb $0x1, %r9b
jne 0x1144e
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r9d
notl %r9d
testl $0x7fff, %r9d           # imm = 0x7FFF
setne %r9b
testq %rax, %rdx
sete %al
orb %r9b, %al
je 0x1144e
movl %ecx, %eax
xorw %si, %ax
js 0x11459
testw %si, %si
js 0x11470
cmpw %cx, %si
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x1147d
orb $0x1, 0x2(%r8)
xorl %eax, %eax
movzbl %al, %eax
retq
testw %si, %si
js 0x11487
orl %esi, %ecx
addl %ecx, %ecx
movzwl %cx, %eax
orq %rdi, %rax
orq %rdx, %rax
sete %al
jmp 0x11455
cmpw %si, %cx
setb %cl
sete %sil
cmpq %rdi, %rdx
setbe %al
andb %sil, %al
orb %cl, %al
jmp 0x11455
movb $0x1, %al
jmp 0x11455
// File: /workspace/github_c_makefile_star2_O1/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
testl $0x7fff, %eax           # imm = 0x7FFF
setne %al
leaq (,%rdi,2), %r9
testq %r9, %r9
sete %r9b
orb %al, %r9b
cmpb $0x1, %r9b
jne 0x114f0
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r9d
notl %r9d
testl $0x7fff, %r9d           # imm = 0x7FFF
setne %r9b
testq %rax, %rdx
sete %al
orb %r9b, %al
je 0x114f0
movl %ecx, %eax
xorw %si, %ax
js 0x114fb
testw %si, %si
js 0x11512
cmpw %cx, %si
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x1151f
orb $0x1, 0x2(%r8)
xorl %eax, %eax
movzbl %al, %eax
retq
testw %si, %si
jns 0x114f5
orl %esi, %ecx
addl %ecx, %ecx
movzwl %cx, %eax
orq %rdi, %rax
orq %rdx, %rax
setne %al
jmp 0x114f7
cmpw %si, %cx
setb %cl
sete %sil
cmpq %rdi, %rdx
setb %al
andb %sil, %al
orb %cl, %al
jmp 0x114f7
// File: /workspace/github_c_makefile_star2_O1/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
testl $0x7fff, %esi           # imm = 0x7FFF
setne %al
shlq %rdi
testq %rdi, %rdi
sete %sil
orb %al, %sil
cmpb $0x1, %sil
jne 0x11568
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
notl %ecx
testl $0x7fff, %ecx           # imm = 0x7FFF
setne %cl
testq %rax, %rdx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x11572
orb $0x1, 0x2(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x7fff, %r9d           # imm = 0x7FFF
movl %esi, %eax
andl %r9d, %eax
cmpl %r9d, %eax
setne %r9b
leaq (,%rdi,2), %r10
testq %r10, %r10
sete %r10b
orb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x115ed
movabsq $0x7fffffffffffffff, %r9 # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r10d
notl %r10d
testl $0x7fff, %r10d          # imm = 0x7FFF
setne %r10b
testq %r9, %rdx
sete %r9b
orb %r10b, %r9b
je 0x115ed
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0x115ec
movl $0x1, %eax
cmpw %cx, %si
je 0x115ec
movl $0x0, %eax
testq %rdi, %rdi
jne 0x115ec
orl %esi, %ecx
xorl %eax, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
sete %al
retq
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
movzwl %ax, %eax
leaq 0x1(%r9), %rsi
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x11612
movq %rdi, %rax
andq %r9, %rax
je 0x11612
andq %rsi, %rdi
je 0x11628
notl %ecx
xorl %eax, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
jne 0x115ec
andq %rdx, %r9
je 0x115ec
andq %rsi, %rdx
jne 0x115ec
orb $0x1, 0x2(%r8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x7fff, %r9d           # imm = 0x7FFF
movl %esi, %eax
andl %r9d, %eax
cmpl %r9d, %eax
setne %r9b
leaq (,%rdi,2), %r10
testq %r10, %r10
sete %r10b
orb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x11780
movabsq $0x7fffffffffffffff, %r9 # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r10d
notl %r10d
testl $0x7fff, %r10d          # imm = 0x7FFF
setne %r10b
testq %r9, %rdx
sete %r9b
orb %r10b, %r9b
je 0x11780
movl %ecx, %eax
xorw %si, %ax
js 0x117c4
testw %si, %si
js 0x117db
cmpw %cx, %si
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x117e8
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
movzwl %ax, %eax
leaq 0x1(%r9), %rsi
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x117a5
movq %rdi, %rax
andq %r9, %rax
je 0x117a5
andq %rsi, %rdi
je 0x117bb
notl %ecx
xorl %eax, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
jne 0x117f0
andq %rdx, %r9
je 0x117f0
andq %rsi, %rdx
jne 0x117f0
orb $0x1, 0x2(%r8)
xorl %eax, %eax
jmp 0x117f0
testw %si, %si
jns 0x117c0
orl %esi, %ecx
addl %ecx, %ecx
movzwl %cx, %eax
orq %rdi, %rax
orq %rdx, %rax
setne %al
jmp 0x117f0
cmpw %si, %cx
setb %cl
sete %sil
cmpq %rdi, %rdx
setb %al
andb %sil, %al
orb %cl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x7fff, %eax           # imm = 0x7FFF
andl %eax, %esi
cmpl %eax, %esi
setne %al
leaq (,%rdi,2), %r9
testq %r9, %r9
sete %r9b
orb %al, %r9b
cmpb $0x1, %r9b
jne 0x11841
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %ecx, %r9d
notl %r9d
testl $0x7fff, %r9d           # imm = 0x7FFF
setne %r9b
testq %rax, %rdx
sete %r10b
xorl %eax, %eax
orb %r9b, %r10b
jne 0x11889
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
movzwl %si, %eax
leaq 0x1(%r9), %rsi
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x11866
movq %rdi, %rax
andq %r9, %rax
je 0x11866
andq %rsi, %rdi
je 0x1187f
notl %ecx
movl $0x1, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
jne 0x11889
andq %rdx, %r9
je 0x11889
andq %rsi, %rdx
jne 0x11889
orb $0x1, 0x2(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_to_int32
int32 float128_to_int32(float128 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig0, aSig1;

    aSig1 = extractFloat128Frac1( a );
    aSig0 = extractFloat128Frac0( a );
    aExp = extractFloat128Exp( a );
    aSign = extractFloat128Sign( a );
    if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;
    if ( aExp ) aSig0 |= LIT64( 0x0001000000000000 );
    aSig0 |= ( aSig1 != 0 );
    shiftCount = 0x4028 - aExp;
    if ( 0 < shiftCount ) shift64RightJamming( aSig0, shiftCount, &aSig0 );
    return roundAndPackInt32(aSign, aSig0, status);

}

// Assembly:
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
movq %rsi, %r9
andq %rax, %r9
movq %rsi, %r8
shrq $0x30, %r8
andl $0x7fff, %r8d           # imm = 0x7FFF
leaq 0x1(%r9,%rax), %rcx
cmoveq %r9, %rcx
xorl %eax, %eax
testq %rdi, %rdi
setne %al
orq %rcx, %rax
cmpl $0x4027, %r8d           # imm = 0x4027
ja 0x118f5
movl $0x4028, %ecx           # imm = 0x4028
subl %r8d, %ecx
cmpl $0x3f, %ecx
ja 0x118ea
movq %rax, %r10
shrq %cl, %r10
negb %cl
shlq %cl, %rax
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
orq %r10, %rcx
jmp 0x118f2
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movq %rcx, %rax
shrq $0x3f, %rsi
xorl %ecx, %ecx
orq %rdi, %r9
cmovel %esi, %ecx
cmpl $0x7fff, %r8d           # imm = 0x7FFF
cmovnel %esi, %ecx
movl %ecx, %edi
movq %rax, %rsi
jmp 0xa4bf
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_to_int32_round_to_zero
int32 float128_to_int32_round_to_zero(float128 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig0, aSig1, savedASig;
    int32_t z;

    aSig1 = extractFloat128Frac1( a );
    aSig0 = extractFloat128Frac0( a );
    aExp = extractFloat128Exp( a );
    aSign = extractFloat128Sign( a );
    aSig0 |= ( aSig1 != 0 );
    if ( 0x401E < aExp ) {
        if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;
        goto invalid;
    }
    else if ( aExp < 0x3FFF ) {
        if (aExp || aSig0) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    aSig0 |= LIT64( 0x0001000000000000 );
    shiftCount = 0x402F - aExp;
    savedASig = aSig0;
    aSig0 >>= shiftCount;
    z = aSig0;
    if ( aSign ) z = - z;
    if ( ( z < 0 ) ^ aSign ) {
 invalid:
        float_raise(float_flag_invalid, status);
        return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
    }
    if ( ( aSig0<<shiftCount ) != savedASig ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;

}

// Assembly:
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
movq %rsi, %r10
andq %rcx, %r10
movq %rsi, %rax
shrq $0x30, %rax
andl $0x7fff, %eax           # imm = 0x7FFF
movq %rsi, %r8
shrq $0x3f, %r8
xorl %r9d, %r9d
testq %rdi, %rdi
setne %r9b
orq %r10, %r9
cmpl $0x401f, %eax           # imm = 0x401F
jb 0x11974
movzbl %r8b, %ecx
xorl %esi, %esi
testq %r9, %r9
cmovel %ecx, %esi
cmpl $0x7fff, %eax           # imm = 0x7FFF
cmovnel %ecx, %esi
movl %esi, %r8d
orb $0x1, 0x2(%rdx)
cmpb $0x1, %r8b
movl $0x80000000, %eax       # imm = 0x80000000
sbbl $0x0, %eax
retq
cmpl $0x3ffe, %eax           # imm = 0x3FFE
ja 0x11994
testl %eax, %eax
setne %al
testq %r9, %r9
setne %cl
orb %al, %cl
xorl %eax, %eax
cmpb $0x1, %cl
jne 0x11993
orb $0x20, 0x2(%rdx)
retq
leaq (%rcx,%r9), %rdi
incq %rdi
movl $0x402f, %ecx           # imm = 0x402F
subl %eax, %ecx
movq %rdi, %r9
shrq %cl, %r9
movl %r9d, %eax
negl %eax
testq %rsi, %rsi
cmovnsl %r9d, %eax
movl %eax, %esi
shrl $0x1f, %esi
cmpl %r8d, %esi
jne 0x11963
shlq %cl, %r9
cmpq %rdi, %r9
jne 0x1198f
jmp 0x11993
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_to_int64
int64 float128_to_int64(float128 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig0, aSig1;

    aSig1 = extractFloat128Frac1( a );
    aSig0 = extractFloat128Frac0( a );
    aExp = extractFloat128Exp( a );
    aSign = extractFloat128Sign( a );
    if ( aExp ) aSig0 |= LIT64( 0x0001000000000000 );
    shiftCount = 0x402F - aExp;
    if ( shiftCount <= 0 ) {
        if ( 0x403E < aExp ) {
            float_raise(float_flag_invalid, status);
            if (    ! aSign
                 || (    ( aExp == 0x7FFF )
                      && ( aSig1 || ( aSig0 != LIT64( 0x0001000000000000 ) ) )
                    )
               ) {
                return LIT64( 0x7FFFFFFFFFFFFFFF );
            }
            return (int64_t) LIT64( 0x8000000000000000 );
        }
        shortShift128Left( aSig0, aSig1, - shiftCount, &aSig0, &aSig1 );
    }
    else {
        shift64ExtraRightJamming( aSig0, aSig1, shiftCount, &aSig0, &aSig1 );
    }
    return roundAndPackInt64(aSign, aSig0, aSig1, status);

}

// Assembly:
movq %rdx, %r9
movabsq $0x1000000000000, %rdx  # imm = 0x1000000000000
leaq -0x1(%rdx), %rax
andq %rsi, %rax
movq %rsi, %rcx
shrq $0x30, %rcx
andl $0x7fff, %ecx           # imm = 0x7FFF
movq %rax, %r8
btsq $0x30, %r8
testl %ecx, %ecx
cmoveq %rax, %r8
cmpl $0x402f, %ecx           # imm = 0x402F
jb 0x11a1c
cmpl $0x403f, %ecx           # imm = 0x403F
jb 0x11a44
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%r9)
testq %rsi, %rsi
js 0x11a99
retq
movl $0x402f, %eax           # imm = 0x402F
subl %ecx, %eax
cmpl $0x3f, %eax
ja 0x11a63
movl %eax, %ecx
negb %cl
movq %r8, %r10
shlq %cl, %r10
xorl %edx, %edx
testq %rdi, %rdi
setne %dl
orq %r10, %rdx
movl %eax, %ecx
shrq %cl, %r8
jmp 0x11a86
addl $0xffffbfd1, %ecx       # imm = 0xFFFFBFD1
movq %rdi, %rdx
shlq %cl, %rdx
testl %ecx, %ecx
je 0x11a86
movl %ecx, %ecx
shlq %cl, %r8
negb %cl
shrq %cl, %rdi
orq %rdi, %r8
jmp 0x11a86
cmpl $0x3fef, %ecx           # imm = 0x3FEF
jne 0x11a7b
xorl %eax, %eax
testq %rdi, %rdi
setne %al
movq %r8, %rdx
orq %rax, %rdx
jmp 0x11a83
xorl %edx, %edx
orq %rdi, %r8
setne %dl
xorl %r8d, %r8d
shrq $0x3f, %rsi
movzbl %sil, %edi
movq %r8, %rsi
movq %r9, %rcx
jmp 0xa771
cmpl $0x7fff, %ecx           # imm = 0x7FFF
jne 0x11ab3
testq %rdi, %rdi
jne 0x11a1b
cmpq %rdx, %r8
jne 0x11a1b
incq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_to_float32
float32 float128_to_float32(float128 a, float_status *status)
{
    flag aSign;
    int32 aExp;
    uint64_t aSig0, aSig1;
    uint32_t zSig;

    aSig1 = extractFloat128Frac1( a );
    aSig0 = extractFloat128Frac0( a );
    aExp = extractFloat128Exp( a );
    aSign = extractFloat128Sign( a );
    if ( aExp == 0x7FFF ) {
        if ( aSig0 | aSig1 ) {
            return commonNaNToFloat32(float128ToCommonNaN(a, status), status);
        }
        return packFloat32( aSign, 0xFF, 0 );
    }
    aSig0 |= ( aSig1 != 0 );
    shift64RightJamming( aSig0, 18, &aSig0 );
    zSig = aSig0;
    if ( aExp || zSig ) {
        zSig |= 0x40000000;
        aExp -= 0x3F81;
    }
    return roundAndPackFloat32(aSign, aExp, zSig, status);

}

// Assembly:
movq %rdx, %rcx
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
movq %rsi, %r8
shrq $0x30, %r8
movl $0x7fff, %edx           # imm = 0x7FFF
andl %edx, %r8d
movq %rsi, %rax
shrq $0x3f, %rax
cmpl %edx, %r8d
jne 0x11c50
orq %rdi, %r9
je 0x11ca5
movabsq $0x7fff800000000000, %rdx # imm = 0x7FFF800000000000
andq %rsi, %rdx
movabsq $0x7fff000000000000, %r8 # imm = 0x7FFF000000000000
cmpq %r8, %rdx
jne 0x11c29
movabsq $0x7fffffffffff, %rdx   # imm = 0x7FFFFFFFFFFF
andq %rsi, %rdx
orq %rdi, %rdx
je 0x11c29
orb $0x1, 0x2(%rcx)
shrq $0x19, %rsi
andl $0x7fffff, %esi         # imm = 0x7FFFFF
shll $0x1f, %eax
testq %rsi, %rsi
leal 0x7f800000(%rax,%rsi), %eax
movl $0x7fc00000, %edx       # imm = 0x7FC00000
cmovel %edx, %eax
cmpb $0x0, 0x6(%rcx)
cmovnel %edx, %eax
retq
xorl %r10d, %r10d
testq %rdi, %rdi
setne %r10b
shrq $0x12, %r9
andl $0x3ffff, %esi          # imm = 0x3FFFF
xorl %edx, %edx
orq %r10, %rsi
setne %dl
orq %r9, %rdx
testl %r8d, %r8d
setne %sil
testq %rdx, %rdx
setne %dil
orb %sil, %dil
orl $0x40000000, %edx       # imm = 0x40000000
addl $0xffffc07f, %r8d       # imm = 0xFFFFC07F
movslq %r8d, %rsi
xorl %r8d, %r8d
testb %dil, %dil
cmoveq %r8, %rsi
cmovel %r8d, %edx
movl %eax, %edi
jmp 0x9e9b
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_to_float64
float64 float128_to_float64(float128 a, float_status *status)
{
    flag aSign;
    int32 aExp;
    uint64_t aSig0, aSig1;

    aSig1 = extractFloat128Frac1( a );
    aSig0 = extractFloat128Frac0( a );
    aExp = extractFloat128Exp( a );
    aSign = extractFloat128Sign( a );
    if ( aExp == 0x7FFF ) {
        if ( aSig0 | aSig1 ) {
            return commonNaNToFloat64(float128ToCommonNaN(a, status), status);
        }
        return packFloat64( aSign, 0x7FF, 0 );
    }
    shortShift128Left( aSig0, aSig1, 14, &aSig0, &aSig1 );
    aSig0 |= ( aSig1 != 0 );
    if ( aExp || aSig0 ) {
        aSig0 |= LIT64( 0x4000000000000000 );
        aExp -= 0x3C01;
    }
    return roundAndPackFloat64(aSign, aExp, aSig0, status);

}

// Assembly:
movq %rdx, %rcx
movabsq $0xffffffffffff, %r8    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r8
movq %rsi, %rax
shrq $0x30, %rax
movl $0x7fff, %edx           # imm = 0x7FFF
andl %edx, %eax
cmpl %edx, %eax
jne 0x11d56
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
orq %rdi, %r8
je 0x11d9e
movabsq $0x7fff800000000000, %r8 # imm = 0x7FFF800000000000
andq %rsi, %r8
movabsq $0x7fff000000000000, %r9 # imm = 0x7FFF000000000000
cmpq %r9, %r8
jne 0x11d23
movabsq $0x7fffffffffff, %r8    # imm = 0x7FFFFFFFFFFF
andq %rsi, %r8
orq %rdi, %r8
je 0x11d23
orb $0x1, 0x2(%rcx)
shrdq $0x30, %rsi, %rdi
movq %rdi, %r8
shrq $0xc, %r8
andq %rsi, %rax
orq %rdx, %rax
orq %r8, %rax
cmpq $0x1000, %rdi           # imm = 0x1000
movabsq $0x7ff8000000000000, %rdx # imm = 0x7FF8000000000000
cmovbq %rdx, %rax
cmpb $0x0, 0x6(%rcx)
cmovneq %rdx, %rax
retq
shrq $0x3f, %rsi
shldq $0xe, %rdi, %r8
xorl %edx, %edx
shlq $0xe, %rdi
setne %dl
orq %r8, %rdx
testl %eax, %eax
setne %dil
testq %rdx, %rdx
setne %r8b
orb %dil, %r8b
btsq $0x3e, %rdx
addl $0xffffc3ff, %eax       # imm = 0xFFFFC3FF
cltq
xorl %edi, %edi
testb %r8b, %r8b
cmoveq %rdi, %rdx
cmoveq %rdi, %rax
movl %esi, %edi
movq %rax, %rsi
jmp 0xa1a9
andq %rax, %rsi
orq %rdx, %rsi
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_to_floatx80
floatx80 float128_to_floatx80(float128 a, float_status *status)
{
    flag aSign;
    int32 aExp;
    uint64_t aSig0, aSig1;

    aSig1 = extractFloat128Frac1( a );
    aSig0 = extractFloat128Frac0( a );
    aExp = extractFloat128Exp( a );
    aSign = extractFloat128Sign( a );
    if ( aExp == 0x7FFF ) {
        if ( aSig0 | aSig1 ) {
            return commonNaNToFloatx80(float128ToCommonNaN(a, status), status);
        }
        return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
    }
    if ( aExp == 0 ) {
        if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
        normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );
    }
    else {
        aSig0 |= LIT64( 0x0001000000000000 );
    }
    shortShift128Left( aSig0, aSig1, 15, &aSig0, &aSig1 );
    return roundAndPackFloatx80(80, aSign, aExp, aSig0, aSig1, status);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %rax
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
andq %rcx, %rdi
movq %rdi, 0x8(%rsp)
movq %rsi, %rdx
shrq $0x30, %rdx
movq %rsi, %r14
shrq $0x3f, %r14
andl $0x7fff, %edx           # imm = 0x7FFF
movl %edx, 0x4(%rsp)
je 0x11e7a
cmpl $0x7fff, %edx           # imm = 0x7FFF
jne 0x11e9b
orq %rax, %rdi
je 0x11ee0
movabsq $0x7fff800000000000, %rcx # imm = 0x7FFF800000000000
andq %rsi, %rcx
movabsq $0x7fff000000000000, %rdx # imm = 0x7FFF000000000000
cmpq %rdx, %rcx
jne 0x11e34
movabsq $0x7fffffffffff, %rcx   # imm = 0x7FFFFFFFFFFF
andq %rsi, %rcx
orq %rax, %rcx
je 0x11e34
orb $0x1, 0x2(%rbx)
shldq $0x10, %rax, %rsi
cmpb $0x0, 0x6(%rbx)
setne %al
cmpq $0x2, %rsi
setb %cl
orb %al, %cl
shrq %rsi
btsq $0x3f, %rsi
shll $0xf, %r14d
orl $0x7fff, %r14d          # imm = 0x7FFF
testb %cl, %cl
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
cmoveq %rsi, %rax
movl $0xffff, %edx           # imm = 0xFFFF
cmovel %r14d, %edx
jmp 0x11f00
movq %rdi, %rcx
orq %rax, %rcx
je 0x11ef7
leaq 0x4(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rax, %rsi
callq 0x11f08
jmp 0x11ea7
leaq (%rcx,%rdi), %rax
incq %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
shldq $0xf, %r8, %rcx
shlq $0xf, %r8
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl 0x4(%rsp), %edx
movzbl %r14b, %esi
movl $0x50, %edi
movq %rbx, %r9
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x1060d
shll $0xf, %r14d
orl $0x7fff, %r14d          # imm = 0x7FFF
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
jmp 0x11efd
shll $0xf, %r14d
xorl %eax, %eax
movl %r14d, %edx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: normalizeFloat128Subnormal
static void
 normalizeFloat128Subnormal(
     uint64_t aSig0,
     uint64_t aSig1,
     int32 *zExpPtr,
     uint64_t *zSig0Ptr,
     uint64_t *zSig1Ptr
 )
{
    int8 shiftCount;

    if ( aSig0 == 0 ) {
        shiftCount = countLeadingZeros64( aSig1 ) - 15;
        if ( shiftCount < 0 ) {
            *zSig0Ptr = aSig1>>( - shiftCount );
            *zSig1Ptr = aSig1<<( shiftCount & 63 );
        }
        else {
            *zSig0Ptr = aSig1<<shiftCount;
            *zSig1Ptr = 0;
        }
        *zExpPtr = - shiftCount - 63;
    }
    else {
        shiftCount = countLeadingZeros64( aSig0 ) - 15;
        shortShift128Left( aSig0, aSig1, shiftCount, zSig0Ptr, zSig1Ptr );
        *zExpPtr = 1 - shiftCount;
    }

}

// Assembly:
movq %rcx, %rax
testq %rdi, %rdi
je 0x11f50
bsrq %rdi, %r10
xorl $0x3f, %r10d
addb $-0xf, %r10b
movsbq %r10b, %r9
movq %rsi, %r11
movl %r9d, %ecx
shlq %cl, %r11
movq %r11, (%r8)
testb %r9b, %r9b
je 0x11f43
movl %r10d, %ecx
shlq %cl, %rdi
negb %r10b
movl %r10d, %ecx
shrq %cl, %rsi
orq %rsi, %rdi
movq %rdi, (%rax)
movl $0x1, %eax
subl %r9d, %eax
jmp 0x11f9e
testq %rsi, %rsi
je 0x11f5f
bsrq %rsi, %rdi
xorq $0x3f, %rdi
jmp 0x11f64
movl $0x40, %edi
addb $-0xf, %dil
movsbl %dil, %r9d
movq %rsi, %rcx
shrq $0x31, %rcx
je 0x11f89
movl %edi, %ecx
negb %cl
movq %rsi, %r10
shrq %cl, %r10
movq %r10, (%rax)
movl %edi, %ecx
shlq %cl, %rsi
jmp 0x11f93
movl %edi, %ecx
shlq %cl, %rsi
movq %rsi, (%rax)
xorl %esi, %esi
movq %rsi, (%r8)
movl $0xffffffc1, %eax       # imm = 0xFFFFFFC1
subl %r9d, %eax
movl %eax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_eq
int float128_eq(float128 a, float128 b, float_status *status)
{

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

}

// Assembly:
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
movq %rsi, %r9
notq %r9
testq %rax, %r9
jne 0x13cc7
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x13ce4
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x13cec
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
je 0x13cec
orb $0x1, 0x2(%r8)
xorl %eax, %eax
retq
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0x13d07
movl $0x1, %eax
cmpq %rcx, %rsi
je 0x13d07
movl $0x0, %eax
testq %rdi, %rdi
je 0x13d08
retq
orq %rsi, %rcx
shlq %rcx
xorl %eax, %eax
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_le
int float128_le(float128 a, float128 b, float_status *status)
{
    flag aSign, bSign;

    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
         || (    ( extractFloat128Exp( b ) == 0x7FFF )
              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    aSign = extractFloat128Sign( a );
    bSign = extractFloat128Sign( b );
    if ( aSign != bSign ) {
        return
               aSign
            || (    ( ( (uint64_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:
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
movq %rsi, %r9
notq %r9
testq %rax, %r9
jne 0x13d3e
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x13d5b
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x13d64
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
je 0x13d64
orb $0x1, 0x2(%r8)
xorl %eax, %eax
jmp 0x13dab
movq %rcx, %rax
xorq %rsi, %rax
js 0x13d80
testq %rsi, %rsi
js 0x13d96
cmpq %rcx, %rsi
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x13da3
testq %rsi, %rsi
js 0x13daf
orq %rsi, %rcx
addq %rcx, %rcx
orq %rdi, %rcx
orq %rdx, %rcx
sete %al
jmp 0x13dab
cmpq %rsi, %rcx
setb %cl
sete %sil
cmpq %rdi, %rdx
setbe %al
andb %sil, %al
orb %cl, %al
movzbl %al, %eax
retq
movb $0x1, %al
jmp 0x13dab
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_lt
int float128_lt(float128 a, float128 b, float_status *status)
{
    flag aSign, bSign;

    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
         || (    ( extractFloat128Exp( b ) == 0x7FFF )
              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    aSign = extractFloat128Sign( a );
    bSign = extractFloat128Sign( b );
    if ( aSign != bSign ) {
        return
               aSign
            && (    ( ( (uint64_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:
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
movq %rsi, %r9
notq %r9
testq %rax, %r9
jne 0x13dda
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x13df7
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x13e00
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
je 0x13e00
orb $0x1, 0x2(%r8)
xorl %eax, %eax
jmp 0x13e47
movq %rcx, %rax
xorq %rsi, %rax
js 0x13e1c
testq %rsi, %rsi
js 0x13e32
cmpq %rcx, %rsi
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x13e3f
testq %rsi, %rsi
jns 0x13dfc
orq %rsi, %rcx
addq %rcx, %rcx
orq %rdi, %rcx
orq %rdx, %rcx
setne %al
jmp 0x13e47
cmpq %rsi, %rcx
setb %cl
sete %sil
cmpq %rdi, %rdx
setb %al
andb %sil, %al
orb %cl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_unordered
int float128_unordered(float128 a, float128 b, float_status *status)
{
    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
         || (    ( extractFloat128Exp( b ) == 0x7FFF )
              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 1;
    }
    return 0;
}

// Assembly:
movabsq $0x7fff000000000000, %r9 # imm = 0x7FFF000000000000
movq %rsi, %rax
notq %rax
testq %r9, %rax
jne 0x13e72
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rsi
orq %rdi, %rsi
jne 0x13e91
movq %rcx, %rsi
notq %rsi
xorl %eax, %eax
testq %rsi, %r9
jne 0x13e9b
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
je 0x13e9b
orb $0x1, 0x2(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_eq_quiet
int float128_eq_quiet(float128 a, float128 b, float_status *status)
{

    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
         || (    ( extractFloat128Exp( b ) == 0x7FFF )
              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
       ) {
        if (    float128_is_signaling_nan( a )
             || float128_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 0;
    }
    return
           ( a.low == b.low )
        && (    ( a.high == b.high )
             || (    ( a.low == 0 )
                  && ( (uint64_t) ( ( a.high | b.high )<<1 ) == 0 ) )
           );

}

// Assembly:
movabsq $0x7fff000000000000, %r9 # imm = 0x7FFF000000000000
movq %rsi, %rax
notq %rax
testq %r9, %rax
jne 0x13ec3
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
orq %rdi, %rax
jne 0x13ee0
movq %rcx, %rax
notq %rax
testq %rax, %r9
jne 0x13f21
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
je 0x13f21
movabsq $0x7fff800000000000, %r11 # imm = 0x7FFF800000000000
movabsq $0x7fffffffffff, %r10   # imm = 0x7FFFFFFFFFFF
movq %rsi, %rax
andq %r11, %rax
cmpq %r9, %rax
jne 0x13f07
andq %r10, %rsi
orq %rdi, %rsi
jne 0x13f19
andq %rcx, %r11
xorl %eax, %eax
cmpq %r9, %r11
jne 0x13f3c
andq %r10, %rcx
orq %rdx, %rcx
je 0x13f3c
orb $0x1, 0x2(%r8)
xorl %eax, %eax
retq
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0x13f3c
movl $0x1, %eax
cmpq %rcx, %rsi
je 0x13f3c
movl $0x0, %eax
testq %rdi, %rdi
je 0x13f3d
retq
orq %rsi, %rcx
shlq %rcx
xorl %eax, %eax
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_le_quiet
int float128_le_quiet(float128 a, float128 b, float_status *status)
{
    flag aSign, bSign;

    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
         || (    ( extractFloat128Exp( b ) == 0x7FFF )
              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
       ) {
        if (    float128_is_signaling_nan( a )
             || float128_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 0;
    }
    aSign = extractFloat128Sign( a );
    bSign = extractFloat128Sign( b );
    if ( aSign != bSign ) {
        return
               aSign
            || (    ( ( (uint64_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:
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
movq %rsi, %r9
notq %r9
testq %rax, %r9
jne 0x13f73
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x13f90
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x13fd2
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rcx, %r9
orq %rdx, %r9
je 0x13fd2
movabsq $0x7fff800000000000, %r10 # imm = 0x7FFF800000000000
movabsq $0x7fffffffffff, %r9    # imm = 0x7FFFFFFFFFFF
movq %rsi, %r11
andq %r10, %r11
cmpq %rax, %r11
jne 0x13fb7
andq %r9, %rsi
orq %rdi, %rsi
jne 0x13fc9
andq %rcx, %r10
xorl %esi, %esi
cmpq %rax, %r10
jne 0x1401a
andq %r9, %rcx
orq %rdx, %rcx
je 0x1401a
orb $0x1, 0x2(%r8)
xorl %esi, %esi
jmp 0x1401a
movq %rcx, %rax
xorq %rsi, %rax
js 0x13fed
testq %rsi, %rsi
js 0x14004
cmpq %rcx, %rsi
setb %al
sete %cl
cmpq %rdx, %rdi
jmp 0x14010
testq %rsi, %rsi
js 0x1401f
orq %rsi, %rcx
addq %rcx, %rcx
orq %rdi, %rcx
orq %rdx, %rcx
sete %sil
jmp 0x1401a
cmpq %rsi, %rcx
setb %al
sete %cl
cmpq %rdi, %rdx
setbe %sil
andb %cl, %sil
orb %al, %sil
movzbl %sil, %eax
retq
movb $0x1, %sil
jmp 0x1401a
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_lt_quiet
int float128_lt_quiet(float128 a, float128 b, float_status *status)
{
    flag aSign, bSign;

    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
         || (    ( extractFloat128Exp( b ) == 0x7FFF )
              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
       ) {
        if (    float128_is_signaling_nan( a )
             || float128_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 0;
    }
    aSign = extractFloat128Sign( a );
    bSign = extractFloat128Sign( b );
    if ( aSign != bSign ) {
        return
               aSign
            && (    ( ( (uint64_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:
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
movq %rsi, %r9
notq %r9
testq %rax, %r9
jne 0x1404b
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x14068
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x140a8
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rcx, %r9
orq %rdx, %r9
je 0x140a8
movabsq $0x7fff800000000000, %r10 # imm = 0x7FFF800000000000
movabsq $0x7fffffffffff, %r9    # imm = 0x7FFFFFFFFFFF
movq %rsi, %r11
andq %r10, %r11
cmpq %rax, %r11
jne 0x1408f
andq %r9, %rsi
orq %rdi, %rsi
jne 0x140a1
andq %rcx, %r10
xorl %esi, %esi
cmpq %rax, %r10
jne 0x140e2
andq %r9, %rcx
orq %rdx, %rcx
je 0x140e2
orb $0x1, 0x2(%r8)
jmp 0x140c8
movq %rcx, %rax
xorq %rsi, %rax
js 0x140c3
testq %rsi, %rsi
js 0x140cc
cmpq %rcx, %rsi
setb %al
sete %cl
cmpq %rdx, %rdi
jmp 0x140d8
testq %rsi, %rsi
js 0x140e7
xorl %esi, %esi
jmp 0x140e2
cmpq %rsi, %rcx
setb %al
sete %cl
cmpq %rdi, %rdx
setb %sil
andb %cl, %sil
orb %al, %sil
movzbl %sil, %eax
retq
orq %rsi, %rcx
addq %rcx, %rcx
orq %rdi, %rcx
orq %rdx, %rcx
setne %sil
jmp 0x140e2
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_unordered_quiet
int float128_unordered_quiet(float128 a, float128 b, float_status *status)
{
    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )
              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )
         || (    ( extractFloat128Exp( b ) == 0x7FFF )
              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )
       ) {
        if (    float128_is_signaling_nan( a )
             || float128_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 1;
    }
    return 0;
}

// Assembly:
movabsq $0x7fff000000000000, %r9 # imm = 0x7FFF000000000000
movq %rsi, %rax
notq %rax
testq %r9, %rax
jne 0x14120
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
orq %rdi, %rax
jne 0x1413f
movq %rcx, %r10
notq %r10
xorl %eax, %eax
testq %r10, %r9
jne 0x14185
movabsq $0xffffffffffff, %r10   # imm = 0xFFFFFFFFFFFF
andq %rcx, %r10
orq %rdx, %r10
je 0x14185
movabsq $0x7fff800000000000, %r11 # imm = 0x7FFF800000000000
movabsq $0x7fffffffffff, %r10   # imm = 0x7FFFFFFFFFFF
movq %rsi, %rax
andq %r11, %rax
cmpq %r9, %rax
jne 0x14166
andq %r10, %rsi
orq %rdi, %rsi
jne 0x1417b
andq %rcx, %r11
movl $0x1, %eax
cmpq %r9, %r11
jne 0x14185
andq %r10, %rcx
orq %rdx, %rcx
je 0x14185
orb $0x1, 0x2(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_uint32
uint32 float32_to_uint32(float32 a, float_status *status)
{
    int64_t v;
    uint32 res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float32_to_int64(a, status);
    if (v < 0) {
        res = 0;
    } else if (v > 0xffffffff) {
        res = 0xffffffff;
    } else {
        return v;
    }
    set_float_exception_flags(old_exc_flags, status);
    float_raise(float_flag_invalid, status);
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x2(%rsi), %bpl
callq 0xa6a7
testq %rax, %rax
js 0x141be
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
jg 0x141c0
movl %ecx, %eax
jmp 0x141c8
xorl %eax, %eax
orb $0x1, %bpl
movb %bpl, 0x2(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_int16
int_fast16_t float32_to_int16(float32 a, float_status *status)
{
    int32_t v;
    int_fast16_t res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float32_to_int32(a, status);
    if (v < -0x8000) {
        res = -0x8000;
    } else if (v > 0x7fff) {
        res = 0x7fff;
    } else {
        return v;
    }

    set_float_exception_flags(old_exc_flags, status);
    float_raise(float_flag_invalid, status);
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x2(%rsi), %bpl
callq 0xa41d
movl %eax, %ecx
movq $-0x8000, %rax          # imm = 0x8000
cmpl $0xffff8000, %ecx       # imm = 0xFFFF8000
jl 0x14237
movl $0x7fff, %eax           # imm = 0x7FFF
cmpl $0x7fff, %ecx           # imm = 0x7FFF
jle 0x14241
orb $0x1, %bpl
movb %bpl, 0x2(%rbx)
jmp 0x14244
movslq %ecx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_uint16
uint_fast16_t float32_to_uint16(float32 a, float_status *status)
{
    int32_t v;
    uint_fast16_t res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float32_to_int32(a, status);
    if (v < 0) {
        res = 0;
    } else if (v > 0xffff) {
        res = 0xffff;
    } else {
        return v;
    }

    set_float_exception_flags(old_exc_flags, status);
    float_raise(float_flag_invalid, status);
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x2(%rsi), %bpl
callq 0xa41d
testl %eax, %eax
js 0x14271
movl %eax, %ecx
movl $0xffff, %eax           # imm = 0xFFFF
cmpl $0xffff, %ecx           # imm = 0xFFFF
jg 0x14273
movl %ecx, %eax
jmp 0x1427b
xorl %eax, %eax
orb $0x1, %bpl
movb %bpl, 0x2(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_uint16_round_to_zero
uint_fast16_t float32_to_uint16_round_to_zero(float32 a, float_status *status)
{
    int64_t v;
    uint_fast16_t res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float32_to_int64_round_to_zero(a, status);
    if (v < 0) {
        res = 0;
    } else if (v > 0xffff) {
        res = 0xffff;
    } else {
        return v;
    }
    set_float_exception_flags(old_exc_flags, status);
    float_raise(float_flag_invalid, status);
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x2(%rsi), %bpl
callq 0xa9c5
testq %rax, %rax
js 0x142a5
movl $0xffff, %ecx           # imm = 0xFFFF
cmpq $0x10000, %rax          # imm = 0x10000
jge 0x142a7
jmp 0x142b2
xorl %ecx, %ecx
orb $0x1, %bpl
movb %bpl, 0x2(%rbx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_uint32
uint32 float64_to_uint32(float64 a, float_status *status)
{
    uint64_t v;
    uint32 res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float64_to_uint64(a, status);
    if (v > 0xffffffff) {
        res = 0xffffffff;
    } else {
        return v;
    }
    set_float_exception_flags(old_exc_flags, status);
    float_raise(float_flag_invalid, status);
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x2(%rsi), %bpl
callq 0x142e5
movq %rax, %rcx
shrq $0x20, %rcx
je 0x142de
orb $0x1, %bpl
movb %bpl, 0x2(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_uint64
uint64_t float64_to_uint64(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 (aSign && (aExp > 1022)) {
        float_raise(float_flag_invalid, status);
        if (float64_is_any_nan(a)) {
            return LIT64(0xFFFFFFFFFFFFFFFF);
        } else {
            return 0;
        }
    }
    if (aExp) {
        aSig |= LIT64(0x0010000000000000);
    }
    shiftCount = 0x433 - aExp;
    if (shiftCount <= 0) {
        if (0x43E < aExp) {
            float_raise(float_flag_invalid, status);
            return LIT64(0xFFFFFFFFFFFFFFFF);
        }
        aSigExtra = 0;
        aSig <<= -shiftCount;
    } else {
        shift64ExtraRightJamming(aSig, 0, shiftCount, &aSig, &aSigExtra);
    }
    return roundAndPackUint64(aSign, aSig, aSigExtra, status);
}

// Assembly:
movq %rsi, %rax
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
movabsq $0xfffffffffffff, %r8   # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rsi)
je 0x14328
testq %rdx, %rdi
setne %cl
testq %r8, %rdi
sete %sil
orb %cl, %sil
jne 0x14328
orb $0x40, 0x2(%rax)
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
incq %rcx
andq %rcx, %rdi
movq %rdi, %rcx
shrq $0x34, %rcx
movl %ecx, %esi
andl $0x7ff, %esi            # imm = 0x7FF
testq %rdi, %rdi
setns %r9b
cmpq $0x3ff, %rsi            # imm = 0x3FF
setb %r10b
orb %r9b, %r10b
jne 0x14360
orb $0x1, 0x2(%rax)
btrq $0x3f, %rdi
xorl %eax, %eax
cmpq %rdi, %rdx
sbbq %rax, %rax
retq
movq %rdi, %r9
andq %r8, %r9
testq %rsi, %rsi
leaq 0x1(%r8,%r9), %rdx
cmoveq %r9, %rdx
cmpq $0x433, %rsi            # imm = 0x433
jb 0x1438f
cmpl $0x43f, %esi            # imm = 0x43F
jb 0x143b0
orb $0x1, 0x2(%rax)
movq $-0x1, %rax
retq
cmpl $0x3f4, %esi            # imm = 0x3F4
jb 0x143c3
addb $0xd, %cl
movq %rdx, %r8
shlq %cl, %r8
movb $0x33, %cl
subb %sil, %cl
shrq %cl, %rdx
movq %rdx, %rsi
movq %r8, %rdx
jmp 0x143dc
addq $-0x433, %rsi           # imm = 0xFBCD
movl %esi, %ecx
shlq %cl, %rdx
movq %rdx, %rsi
xorl %edx, %edx
jmp 0x143dc
cmpl $0x3f3, %esi            # imm = 0x3F3
jne 0x143cf
xorl %esi, %esi
jmp 0x143dc
xorl %ecx, %ecx
testq %rdx, %rdx
setne %cl
xorl %esi, %esi
movq %rcx, %rdx
shrq $0x3f, %rdi
movzbl %dil, %edi
movq %rax, %rcx
jmp 0xa908