LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdx, %rcx
movq %rdi, %rax
movzwl %si, %edi
movl $0x7fff, %edx           # imm = 0x7FFF
andl %edx, %esi
shrl $0xf, %edi
cmpl %edx, %esi
jne 0xfc49
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
leaq -0x1(%rsi), %r8
testq %r8, %rax
je 0xfc7a
leaq (,%rax,4), %r8
testq %r8, %r8
je 0xfc08
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
incq %r8
andq %rax, %r8
jne 0xfc08
orb $0x1, 0x2(%rcx)
leaq (%rax,%rax), %r8
movzwl %di, %edi
shlq $0x3f, %rdi
testq %rax, %rax
cmovnsq %rsi, %r8
cmovnsq %rsi, %rdi
movq %r8, %rax
shrq $0xc, %rax
orq %rdx, %rax
orq %rdi, %rax
cmpq $0x1000, %r8            # imm = 0x1000
movabsq $0x7ff8000000000000, %rdx # imm = 0x7FF8000000000000
cmovbq %rdx, %rax
cmpb $0x0, 0x6(%rcx)
cmovneq %rdx, %rax
retq
movzwl %si, %esi
movq %rax, %r8
shrq %r8
movl %eax, %edx
andl $0x1, %edx
orq %r8, %rdx
leaq -0x3c01(%rsi), %r8
testq %rax, %rax
cmovneq %r8, %rax
testw %si, %si
cmovneq %r8, %rax
movzwl %di, %edi
movq %rax, %rsi
jmp 0xa25f
movzwl %di, %eax
shlq $0x3f, %rax
orq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
movzwl %si, %ecx
movl $0x7fff, %edi           # imm = 0x7FFF
andl %edi, %esi
shrl $0xf, %ecx
cmpl %edi, %esi
jne 0xfce2
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
leaq -0x1(%rdi), %r8
andq %rax, %r8
je 0xfce2
leaq (,%rax,4), %rsi
testq %rsi, %rsi
je 0xfccf
movabsq $0x3fffffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFFFF
incq %rsi
andq %rax, %rsi
jne 0xfccf
orb $0x1, 0x2(%rdx)
cmpb $0x0, 0x6(%rdx)
je 0xfd0d
movabsq $0x7fff800000000000, %rdx # imm = 0x7FFF800000000000
xorl %eax, %eax
retq
movzwl %cx, %ecx
movq %rax, %rdx
shrq $0xf, %rdx
movabsq $0xffffffffffff, %rdi   # imm = 0xFFFFFFFFFFFF
andq %rdx, %rdi
shlq $0x31, %rax
shlq $0x3f, %rcx
orq %rdi, %rcx
movzwl %si, %edx
shlq $0x30, %rdx
jmp 0xfd3b
movzwl %cx, %ecx
shlq $0x3f, %rcx
testq %rax, %rax
leaq (%rax,%rax), %rax
cmovnsq %rdi, %rax
cmovnsq %rdi, %rcx
movq %rax, %rsi
shrq $0x10, %rsi
shlq $0x30, %rax
movabsq $0x7fff000000000000, %rdx # imm = 0x7FFF000000000000
orq %rsi, %rdx
orq %rcx, %rdx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
movl %esi, %eax
notl %eax
testl $0x7fff, %eax           # imm = 0x7FFF
sete %bl
leaq 0x1(%r9), %r10
testq %r10, %rdi
setne %bpl
sete %al
leaq (,%rdi,4), %r11
testq %r11, %r11
setne %r12b
andb %bl, %r12b
andb %al, %r12b
movl $0x7fff, %eax           # imm = 0x7FFF
movl %ecx, %r11d
andl %eax, %r11d
cmpl %eax, %r11d
sete %r14b
testq %r10, %rdx
setne %r13b
sete %r15b
leaq (,%rdx,4), %rax
testq %rax, %rax
setne %al
andb %r14b, %r15b
andb %al, %r15b
testb %r12b, %r12b
jne 0xff7e
testb %r15b, %r15b
je 0xff83
orb $0x1, 0x2(%r8)
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
cmpb $0x0, 0x6(%r8)
je 0xff9d
movw $0xffff, %cx            # imm = 0xFFFF
jmp 0x10025
cmpq %rdx, %rdi
jae 0xffa7
xorl %r8d, %r8d
jmp 0xffb3
movb $0x1, %r8b
ja 0xffb3
cmpw %cx, %si
setb %r8b
andb %r13b, %r14b
testb %r12b, %r12b
je 0xffd5
xorl %ebx, %ebx
testb %r8b, %r8b
sete %bl
movzbl %r14b, %r8d
testb %r15b, %r15b
cmovel %r8d, %ebx
cmpb $0x1, %bl
je 0xffe6
jmp 0x10012
andb %bpl, %bl
je 0xffe6
orb %r15b, %r8b
sete %r8b
testb %r8b, %r14b
je 0x10012
testq %r10, %rdx
setne %sil
testq %r9, %rdx
sete %dil
orb %sil, %dil
orq %rdx, %rax
testb $0x1, %dil
cmovneq %rdx, %rax
movzwl %r11w, %esi
cmpl $0x7fff, %esi           # imm = 0x7FFF
cmovneq %rdx, %rax
jmp 0x10025
orq %rdi, %rax
testq %r10, %rdi
cmovneq %rdi, %rax
testq %r9, %rdi
cmoveq %rdi, %rax
movl %esi, %ecx
movl %ecx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10055
movzbl %al, %r8d
jmp 0x1005e
movzbl %al, %r8d
jmp 0x10235
// File: /workspace/github_c_makefile_star2_O3/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 0x1108d
bsrq %rax, %r11
xorq $0x3f, %r11
jmp 0x11093
movl $0x40, %r11d
testq %r11, %r11
je 0x110ab
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 0x10615
// File: /workspace/github_c_makefile_star2_O3/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 0x113fd
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 0x113fd
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0x113fc
movl $0x1, %eax
cmpw %cx, %si
je 0x113fc
movl $0x0, %eax
testq %rdi, %rdi
jne 0x113fc
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_O3/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 0x1146a
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 0x1146a
movl %ecx, %eax
xorw %si, %ax
js 0x11475
testw %si, %si
js 0x1148c
cmpw %cx, %si
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x11499
orb $0x1, 0x2(%r8)
xorl %eax, %eax
movzbl %al, %eax
retq
testw %si, %si
js 0x114a3
orl %esi, %ecx
addl %ecx, %ecx
movzwl %cx, %eax
orq %rdi, %rax
orq %rdx, %rax
sete %al
jmp 0x11471
cmpw %si, %cx
setb %cl
sete %sil
cmpq %rdi, %rdx
setbe %al
andb %sil, %al
orb %cl, %al
jmp 0x11471
movb $0x1, %al
jmp 0x11471
// File: /workspace/github_c_makefile_star2_O3/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 0x1150c
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 0x1150c
movl %ecx, %eax
xorw %si, %ax
js 0x11517
testw %si, %si
js 0x1152e
cmpw %cx, %si
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x1153b
orb $0x1, 0x2(%r8)
xorl %eax, %eax
movzbl %al, %eax
retq
testw %si, %si
jns 0x11511
orl %esi, %ecx
addl %ecx, %ecx
movzwl %cx, %eax
orq %rdi, %rax
orq %rdx, %rax
setne %al
jmp 0x11513
cmpw %si, %cx
setb %cl
sete %sil
cmpq %rdi, %rdx
setb %al
andb %sil, %al
orb %cl, %al
jmp 0x11513
// File: /workspace/github_c_makefile_star2_O3/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 0x11584
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 0x1158e
orb $0x1, 0x2(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11609
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 0x11609
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0x11608
movl $0x1, %eax
cmpw %cx, %si
je 0x11608
movl $0x0, %eax
testq %rdi, %rdi
jne 0x11608
orl %esi, %ecx
xorl %eax, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
sete %al
retq
movzwl %ax, %eax
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
leaq 0x1(%r9), %rsi
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x1162e
movq %rdi, %rax
andq %r9, %rax
je 0x1162e
andq %rsi, %rdi
je 0x11644
notl %ecx
xorl %eax, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
jne 0x11608
andq %rdx, %r9
je 0x11608
andq %rsi, %rdx
jne 0x11608
orb $0x1, 0x2(%r8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1179c
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 0x1179c
movl %ecx, %eax
xorw %si, %ax
js 0x117e0
testw %si, %si
js 0x117f7
cmpw %cx, %si
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x11804
movzwl %ax, %eax
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
leaq 0x1(%r9), %rsi
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x117c1
movq %rdi, %rax
andq %r9, %rax
je 0x117c1
andq %rsi, %rdi
je 0x117d7
notl %ecx
xorl %eax, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
jne 0x1180c
andq %rdx, %r9
je 0x1180c
andq %rsi, %rdx
jne 0x1180c
orb $0x1, 0x2(%r8)
xorl %eax, %eax
jmp 0x1180c
testw %si, %si
jns 0x117dc
orl %esi, %ecx
addl %ecx, %ecx
movzwl %cx, %eax
orq %rdi, %rax
orq %rdx, %rax
setne %al
jmp 0x1180c
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_O3/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 0x1185d
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 0x118a5
movzwl %si, %eax
movabsq $0x3fffffffffffffff, %r9 # imm = 0x3FFFFFFFFFFFFFFF
leaq 0x1(%r9), %rsi
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x11882
movq %rdi, %rax
andq %r9, %rax
je 0x11882
andq %rsi, %rdi
je 0x1189b
notl %ecx
movl $0x1, %eax
testl $0x7fff, %ecx           # imm = 0x7FFF
jne 0x118a5
andq %rdx, %r9
je 0x118a5
andq %rsi, %rdx
jne 0x118a5
orb $0x1, 0x2(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %ecx, %ecx
testq %rdi, %rdi
setne %cl
orq %r9, %rcx
andl $0x7fff, %r8d           # imm = 0x7FFF
je 0x1190e
addq %rcx, %rax
incq %rax
cmpl $0x4027, %r8d           # imm = 0x4027
ja 0x11916
movl $0x1, %ecx
cmpl $0x3fe9, %r8d           # imm = 0x3FE9
jb 0x1190e
movb $0x28, %cl
subb %r8b, %cl
movq %rax, %r10
shrq %cl, %r10
negb %cl
shlq %cl, %rax
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
orq %r10, %rcx
movq %rcx, %rax
jmp 0x11916
xorl %eax, %eax
testq %rcx, %rcx
setne %al
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 0xa573
// File: /workspace/github_c_makefile_star2_O3/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 0x11995
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 0x119b5
testl %eax, %eax
setne %al
testq %r9, %r9
setne %cl
orb %al, %cl
xorl %eax, %eax
cmpb $0x1, %cl
jne 0x119b4
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 0x11984
shlq %cl, %r9
cmpq %rdi, %r9
jne 0x119b0
jmp 0x119b4
// File: /workspace/github_c_makefile_star2_O3/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 $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
movq %rsi, %r10
andq %rax, %r10
movq %rsi, %rcx
shrq $0x30, %rcx
andl $0x7fff, %ecx           # imm = 0x7FFF
je 0x11aa4
leaq (%rax,%r10), %r8
incq %r8
cmpl $0x402f, %ecx           # imm = 0x402F
jb 0x11a3f
cmpl $0x403f, %ecx           # imm = 0x403F
jb 0x11a67
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%r9)
testq %rsi, %rsi
js 0x11ac2
retq
cmpl $0x3ff0, %ecx           # imm = 0x3FF0
jb 0x11a86
movb $0x2f, %al
subb %cl, %al
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 0x11aaf
addl $0xffffbfd1, %ecx       # imm = 0xFFFFBFD1
movq %rdi, %rdx
shlq %cl, %rdx
testl %ecx, %ecx
je 0x11aaf
movl %ecx, %ecx
shlq %cl, %r8
negb %cl
shrq %cl, %rdi
orq %rdi, %r8
jmp 0x11aaf
movl $0x1, %r10d
cmpl $0x3fef, %ecx           # imm = 0x3FEF
jne 0x11aa4
xorl %eax, %eax
testq %rdi, %rdi
setne %al
movq %r8, %rdx
orq %rax, %rdx
jmp 0x11aac
xorl %edx, %edx
orq %rdi, %r10
setne %dl
xorl %r8d, %r8d
shrq $0x3f, %rsi
movzbl %sil, %edi
movq %r8, %rsi
movq %r9, %rcx
jmp 0xa825
leaq 0x1(%rax), %rdx
orq %rdi, %r10
cmoveq %rdx, %rax
cmpl $0x7fff, %ecx           # imm = 0x7FFF
cmovneq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11c74
orq %rdi, %r9
je 0x11cc9
movabsq $0x7fff800000000000, %rdx # imm = 0x7FFF800000000000
andq %rsi, %rdx
movabsq $0x7fff000000000000, %r8 # imm = 0x7FFF000000000000
cmpq %r8, %rdx
jne 0x11c4d
movabsq $0x7fffffffffff, %rdx   # imm = 0x7FFFFFFFFFFF
andq %rsi, %rdx
orq %rdi, %rdx
je 0x11c4d
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 0x9f46
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11d7a
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
orq %rdi, %r8
je 0x11dc2
movabsq $0x7fff800000000000, %r8 # imm = 0x7FFF800000000000
andq %rsi, %r8
movabsq $0x7fff000000000000, %r9 # imm = 0x7FFF000000000000
cmpq %r9, %r8
jne 0x11d47
movabsq $0x7fffffffffff, %r8    # imm = 0x7FFFFFFFFFFF
andq %rsi, %r8
orq %rdi, %r8
je 0x11d47
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 0xa25f
andq %rax, %rsi
orq %rdx, %rsi
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r8
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
andq %rax, %rdi
movq %rdi, 0x18(%rsp)
movq %rsi, %rdx
shrq $0x30, %rdx
movq %rsi, %r13
shrq $0x3f, %r13
andl $0x7fff, %edx           # imm = 0x7FFF
movl %edx, 0xc(%rsp)
je 0x11ea4
cmpl $0x7fff, %edx           # imm = 0x7FFF
jne 0x11ed8
orq %r8, %rdi
je 0x11f06
movabsq $0x7fff800000000000, %rax # imm = 0x7FFF800000000000
andq %rsi, %rax
movabsq $0x7fff000000000000, %rcx # imm = 0x7FFF000000000000
cmpq %rcx, %rax
jne 0x11e5e
movabsq $0x7fffffffffff, %rax   # imm = 0x7FFFFFFFFFFF
andq %rsi, %rax
orq %r8, %rax
je 0x11e5e
orb $0x1, 0x2(%rbx)
shldq $0x10, %r8, %rsi
cmpb $0x0, 0x6(%rbx)
setne %al
cmpq $0x2, %rsi
setb %cl
orb %al, %cl
shrq %rsi
btsq $0x3f, %rsi
shll $0xf, %r13d
orl $0x7fff, %r13d          # imm = 0x7FFF
testb %cl, %cl
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
cmoveq %rsi, %rax
movl $0xffff, %edx           # imm = 0xFFFF
cmovel %r13d, %edx
jmp 0x11f26
movq %rdi, %rax
orq %r8, %rax
je 0x11f1d
leaq 0xc(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r8, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x11f34
movq (%r15), %rcx
movq (%r12), %r8
movl (%r14), %edx
jmp 0x11edf
leaq (%rax,%rdi), %rcx
incq %rcx
shldq $0xf, %r8, %rcx
shlq $0xf, %r8
movzbl %r13b, %esi
movl $0x50, %edi
movq %rbx, %r9
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10615
shll $0xf, %r13d
orl $0x7fff, %r13d          # imm = 0x7FFF
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
jmp 0x11f23
shll $0xf, %r13d
xorl %eax, %eax
movl %r13d, %edx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11f7c
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 0x11f6f
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 0x11fca
testq %rsi, %rsi
je 0x11f8b
bsrq %rsi, %rdi
xorq $0x3f, %rdi
jmp 0x11f90
movl $0x40, %edi
addb $-0xf, %dil
movsbl %dil, %r9d
movq %rsi, %rcx
shrq $0x31, %rcx
je 0x11fb2
movl %edi, %ecx
negb %cl
movq %rsi, %r10
shrq %cl, %r10
movl %edi, %ecx
shlq %cl, %rsi
jmp 0x11fbc
movl %edi, %ecx
shlq %cl, %rsi
movq %rsi, %r10
xorl %esi, %esi
movq %r10, (%rax)
movq %rsi, (%r8)
movl $0xffffffc1, %eax       # imm = 0xFFFFFFC1
subl %r9d, %eax
movl %eax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13cab
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x13cc8
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x13cd0
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
je 0x13cd0
orb $0x1, 0x2(%r8)
xorl %eax, %eax
retq
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0x13ceb
movl $0x1, %eax
cmpq %rcx, %rsi
je 0x13ceb
movl $0x0, %eax
testq %rdi, %rdi
je 0x13cec
retq
orq %rsi, %rcx
shlq %rcx
xorl %eax, %eax
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13d22
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x13d3f
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x13d48
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
je 0x13d48
orb $0x1, 0x2(%r8)
xorl %eax, %eax
jmp 0x13d8f
movq %rcx, %rax
xorq %rsi, %rax
js 0x13d64
testq %rsi, %rsi
js 0x13d7a
cmpq %rcx, %rsi
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x13d87
testq %rsi, %rsi
js 0x13d93
orq %rsi, %rcx
addq %rcx, %rcx
orq %rdi, %rcx
orq %rdx, %rcx
sete %al
jmp 0x13d8f
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 0x13d8f
// File: /workspace/github_c_makefile_star2_O3/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 0x13dbe
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x13ddb
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x13de4
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
je 0x13de4
orb $0x1, 0x2(%r8)
xorl %eax, %eax
jmp 0x13e2b
movq %rcx, %rax
xorq %rsi, %rax
js 0x13e00
testq %rsi, %rsi
js 0x13e16
cmpq %rcx, %rsi
setb %cl
sete %sil
cmpq %rdx, %rdi
jmp 0x13e23
testq %rsi, %rsi
jns 0x13de0
orq %rsi, %rcx
addq %rcx, %rcx
orq %rdi, %rcx
orq %rdx, %rcx
setne %al
jmp 0x13e2b
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_O3/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 0x13e56
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rax, %rsi
orq %rdi, %rsi
jne 0x13e75
movq %rcx, %rsi
notq %rsi
xorl %eax, %eax
testq %rsi, %r9
jne 0x13e7f
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
je 0x13e7f
orb $0x1, 0x2(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13ea7
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
orq %rdi, %rax
jne 0x13ec4
movq %rcx, %rax
notq %rax
testq %rax, %r9
jne 0x13f05
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rax
orq %rdx, %rax
je 0x13f05
movabsq $0x7fff800000000000, %r11 # imm = 0x7FFF800000000000
movabsq $0x7fffffffffff, %r10   # imm = 0x7FFFFFFFFFFF
movq %rsi, %rax
andq %r11, %rax
cmpq %r9, %rax
jne 0x13eeb
andq %r10, %rsi
orq %rdi, %rsi
jne 0x13efd
andq %rcx, %r11
xorl %eax, %eax
cmpq %r9, %r11
jne 0x13f20
andq %r10, %rcx
orq %rdx, %rcx
je 0x13f20
orb $0x1, 0x2(%r8)
xorl %eax, %eax
retq
xorl %eax, %eax
cmpq %rdx, %rdi
jne 0x13f20
movl $0x1, %eax
cmpq %rcx, %rsi
je 0x13f20
movl $0x0, %eax
testq %rdi, %rdi
je 0x13f21
retq
orq %rsi, %rcx
shlq %rcx
xorl %eax, %eax
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13f57
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x13f74
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x13fb6
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rcx, %r9
orq %rdx, %r9
je 0x13fb6
movabsq $0x7fff800000000000, %r10 # imm = 0x7FFF800000000000
movabsq $0x7fffffffffff, %r9    # imm = 0x7FFFFFFFFFFF
movq %rsi, %r11
andq %r10, %r11
cmpq %rax, %r11
jne 0x13f9b
andq %r9, %rsi
orq %rdi, %rsi
jne 0x13fad
andq %rcx, %r10
xorl %esi, %esi
cmpq %rax, %r10
jne 0x13ffe
andq %r9, %rcx
orq %rdx, %rcx
je 0x13ffe
orb $0x1, 0x2(%r8)
xorl %esi, %esi
jmp 0x13ffe
movq %rcx, %rax
xorq %rsi, %rax
js 0x13fd1
testq %rsi, %rsi
js 0x13fe8
cmpq %rcx, %rsi
setb %al
sete %cl
cmpq %rdx, %rdi
jmp 0x13ff4
testq %rsi, %rsi
js 0x14003
orq %rsi, %rcx
addq %rcx, %rcx
orq %rdi, %rcx
orq %rdx, %rcx
sete %sil
jmp 0x13ffe
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 0x13ffe
// File: /workspace/github_c_makefile_star2_O3/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 0x1402f
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rsi, %r9
orq %rdi, %r9
jne 0x1404c
movq %rcx, %r9
notq %r9
testq %r9, %rax
jne 0x1408c
movabsq $0xffffffffffff, %r9    # imm = 0xFFFFFFFFFFFF
andq %rcx, %r9
orq %rdx, %r9
je 0x1408c
movabsq $0x7fff800000000000, %r10 # imm = 0x7FFF800000000000
movabsq $0x7fffffffffff, %r9    # imm = 0x7FFFFFFFFFFF
movq %rsi, %r11
andq %r10, %r11
cmpq %rax, %r11
jne 0x14073
andq %r9, %rsi
orq %rdi, %rsi
jne 0x14085
andq %rcx, %r10
xorl %esi, %esi
cmpq %rax, %r10
jne 0x140c6
andq %r9, %rcx
orq %rdx, %rcx
je 0x140c6
orb $0x1, 0x2(%r8)
jmp 0x140ac
movq %rcx, %rax
xorq %rsi, %rax
js 0x140a7
testq %rsi, %rsi
js 0x140b0
cmpq %rcx, %rsi
setb %al
sete %cl
cmpq %rdx, %rdi
jmp 0x140bc
testq %rsi, %rsi
js 0x140cb
xorl %esi, %esi
jmp 0x140c6
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 0x140c6
// File: /workspace/github_c_makefile_star2_O3/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 0x14104
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rax
orq %rdi, %rax
jne 0x14123
movq %rcx, %r10
notq %r10
xorl %eax, %eax
testq %r10, %r9
jne 0x14169
movabsq $0xffffffffffff, %r10   # imm = 0xFFFFFFFFFFFF
andq %rcx, %r10
orq %rdx, %r10
je 0x14169
movabsq $0x7fff800000000000, %r11 # imm = 0x7FFF800000000000
movabsq $0x7fffffffffff, %r10   # imm = 0x7FFFFFFFFFFF
movq %rsi, %rax
andq %r11, %rax
cmpq %r9, %rax
jne 0x1414a
andq %r10, %rsi
orq %rdi, %rsi
jne 0x1415f
andq %rcx, %r11
movl $0x1, %eax
cmpq %r9, %r11
jne 0x14169
andq %r10, %rcx
orq %rdx, %rcx
je 0x14169
orb $0x1, 0x2(%r8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa75b
testq %rax, %rax
js 0x1419e
movq %rax, %rcx
shrq $0x20, %rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x141a0
movl %ecx, %eax
jmp 0x141a8
xorl %eax, %eax
orb $0x1, %bpl
movb %bpl, 0x2(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq