LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e410
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e430
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e450
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e470
movb %al, -0x29(%rbp)
cmpl $0x7fff, -0x30(%rbp)    # imm = 0x7FFF
jne 0x1ed4a
movq -0x38(%rbp), %rax
orq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x1ed25
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x1eaa0
movq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x13730
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x1ede5
movl $0x7fff, %esi           # imm = 0x7FFF
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movzbl -0x29(%rbp), %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x1ede5
cmpl $0x0, -0x30(%rbp)
jne 0x1ed92
movq -0x38(%rbp), %rax
orq -0x40(%rbp), %rax
cmpq $0x0, %rax
jne 0x1ed77
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movzbl -0x29(%rbp), %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x1ede5
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x1ee00
jmp 0x1eda4
movabsq $0x1000000000000, %rax  # imm = 0x1000000000000
orq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0xf, %edx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x121c0
movb -0x29(%rbp), %al
movl -0x30(%rbp), %edx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x28(%rbp), %r9
movl $0x50, %edi
movzbl %al, %esi
callq 0x1c260
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movw -0x8(%rbp), %dx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1eeae
movq -0x10(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0xf, %eax
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x0, %eax
jge 0x1ee79
movq -0x10(%rbp), %rax
movsbl -0x29(%rbp), %edx
xorl %ecx, %ecx
subl %edx, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movsbl -0x29(%rbp), %ecx
andl $0x3f, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1ee9b
movq -0x10(%rbp), %rax
movsbl -0x29(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movsbl -0x29(%rbp), %eax
xorl %ecx, %ecx
subl %eax, %ecx
subl $0x3f, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1eeeb
movq -0x8(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0xf, %eax
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbq -0x29(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x121c0
movsbl -0x29(%rbp), %eax
movl $0x1, %ecx
subl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float128_add
float128 float128_add(float128 a, float128 b, float_status *status)
{
    flag aSign, bSign;

    aSign = extractFloat128Sign( a );
    bSign = extractFloat128Sign( b );
    if ( aSign == bSign ) {
        return addFloat128Sigs(a, b, aSign, status);
    }
    else {
        return subFloat128Sigs(a, b, aSign, status);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e470
movb %al, -0x39(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1e470
movb %al, -0x3a(%rbp)
movzbl -0x39(%rbp), %eax
movzbl -0x3a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1f672
movb -0x39(%rbp), %al
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movzbl %al, %r8d
callq 0x1f6b0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x1f69a
movb -0x39(%rbp), %al
movq -0x38(%rbp), %r9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movzbl %al, %r8d
callq 0x1faa0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: mul128To256
static inline void
 mul128To256(
     uint64_t a0,
     uint64_t a1,
     uint64_t b0,
     uint64_t b1,
     uint64_t *z0Ptr,
     uint64_t *z1Ptr,
     uint64_t *z2Ptr,
     uint64_t *z3Ptr
 )
{
    uint64_t z0, z1, z2, z3;
    uint64_t more1, more2;

    mul64To128( a1, b1, &z2, &z3 );
    mul64To128( a1, b0, &z1, &more2 );
    add128( z1, more2, 0, z2, &z1, &z2 );
    mul64To128( a0, b0, &z0, &more1 );
    add128( z0, more1, 0, z1, &z0, &z1 );
    mul64To128( a0, b1, &more1, &more2 );
    add128( more1, more2, 0, z2, &more1, &z2 );
    add128( z0, z1, 0, more1, &z0, &z1 );
    *z3Ptr = z3;
    *z2Ptr = z2;
    *z1Ptr = z1;
    *z0Ptr = z0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x18730
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x18730
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x40(%rbp), %r8
leaq -0x48(%rbp), %r9
callq 0x18bd0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x18730
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x18bd0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x18730
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x58(%rbp), %r8
leaq -0x48(%rbp), %r9
callq 0x18bd0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x58(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x18bd0
movq -0x50(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift128ExtraRightJamming
static inline void
 shift128ExtraRightJamming(
     uint64_t a0,
     uint64_t a1,
     uint64_t a2,
     int_fast16_t count,
     uint64_t *z0Ptr,
     uint64_t *z1Ptr,
     uint64_t *z2Ptr
 )
{
    uint64_t z0, z1, z2;
    int8 negCount = ( - count ) & 63;

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
xorl %eax, %eax
subq -0x20(%rbp), %rax
andq $0x3f, %rax
movb %al, -0x49(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x20471
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x2056c
cmpq $0x40, -0x20(%rbp)
jge 0x204bf
movq -0x10(%rbp), %rax
movsbl -0x49(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movsbl -0x49(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq %cl, %rax
movq %rax, -0x38(%rbp)
jmp 0x20555
cmpq $0x40, -0x20(%rbp)
jne 0x204d8
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2054d
movq -0x10(%rbp), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x80, -0x20(%rbp)
jge 0x20514
movq -0x8(%rbp), %rax
movsbl -0x49(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
movq %rax, -0x40(%rbp)
jmp 0x2054b
cmpq $0x80, -0x20(%rbp)
jne 0x20528
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x2053b
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0x2054d
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
orq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: mul128By64To192
static inline void
 mul128By64To192(
     uint64_t a0,
     uint64_t a1,
     uint64_t b,
     uint64_t *z0Ptr,
     uint64_t *z1Ptr,
     uint64_t *z2Ptr
 )
{
    uint64_t z0, z1, z2, more1;

    mul64To128( a1, b, &z1, &z2 );
    mul64To128( a0, b, &z0, &more1 );
    add128( z0, more1, 0, z1, &z0, &z1 );
    *z2Ptr = z2;
    *z1Ptr = z1;
    *z0Ptr = z0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x18730
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x18730
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x18bd0
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shortShift192Left
static inline void
 shortShift192Left(
     uint64_t a0,
     uint64_t a1,
     uint64_t a2,
     int_fast16_t count,
     uint64_t *z0Ptr,
     uint64_t *z1Ptr,
     uint64_t *z2Ptr
 )
{
    uint64_t z0, z1, z2;
    int8 negCount;

    z2 = a2<<count;
    z1 = a1<<count;
    z0 = a0<<count;
    if ( 0 < count ) {
        negCount = ( ( - count ) & 63 );
        z1 |= a2>>negCount;
        z0 |= a1>>negCount;
    }
    *z2Ptr = z2;
    *z1Ptr = z1;
    *z0Ptr = z0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %cl, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %cl, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %cl, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jge 0x2163c
xorl %eax, %eax
subq -0x20(%rbp), %rax
andq $0x3f, %rax
movb %al, -0x49(%rbp)
movq -0x18(%rbp), %rax
movsbl -0x49(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
orq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsbl -0x49(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
orq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x21b3e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e430
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x38(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
jne 0x21b80
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x21b97
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x40(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
je 0x21b97
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x21bed
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x41(%rbp)
jne 0x21be2
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq -0x20(%rbp), %rcx
movb %al, -0x42(%rbp)
je 0x21bdc
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x43(%rbp)
jne 0x21bd6
movq -0x10(%rbp), %rax
orq -0x20(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x43(%rbp)
movb -0x43(%rbp), %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x21c5e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x40(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
jne 0x21ca0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x21cba
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e430
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x48(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
je 0x21cba
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x21d65
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e470
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e470
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
movzbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
je 0x21d1e
movzbl -0x31(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
jne 0x21d11
movq -0x10(%rbp), %rax
orq -0x20(%rbp), %rax
shlq %rax
orq -0x18(%rbp), %rax
orq -0x28(%rbp), %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x21d65
movzbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0x21d44
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1d2d0
movzbl %al, %eax
movl %eax, -0x50(%rbp)
jmp 0x21d5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1d2d0
movzbl %al, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x21dce
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x40(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
jne 0x21e10
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x21e2a
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e430
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x48(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
je 0x21e2a
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x21ed5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e470
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e470
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
movzbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
je 0x21e8e
movzbl -0x31(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
je 0x21e81
movq -0x10(%rbp), %rax
orq -0x20(%rbp), %rax
shlq %rax
orq -0x18(%rbp), %rax
orq -0x28(%rbp), %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x21ed5
movzbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0x21eb4
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x19d70
movzbl %al, %eax
movl %eax, -0x50(%rbp)
jmp 0x21ecf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x19d70
movzbl %al, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x21f3e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e430
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x38(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
jne 0x21f80
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x21f97
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x40(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
je 0x21f97
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x1, -0x4(%rbp)
jmp 0x21f9e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x2200e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e430
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x38(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
jne 0x22050
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x2208b
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x40(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
je 0x2208b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
jne 0x22074
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
je 0x22082
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x220e1
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x41(%rbp)
jne 0x220d6
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq -0x20(%rbp), %rcx
movb %al, -0x42(%rbp)
je 0x220d0
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x43(%rbp)
jne 0x220ca
movq -0x10(%rbp), %rax
orq -0x20(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x43(%rbp)
movb -0x43(%rbp), %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x2214e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x40(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
jne 0x22190
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x221ce
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e430
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x48(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
je 0x221ce
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
jne 0x221b4
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
je 0x221c2
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x22279
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e470
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e470
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
movzbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
je 0x22232
movzbl -0x31(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
jne 0x22225
movq -0x10(%rbp), %rax
orq -0x20(%rbp), %rax
shlq %rax
orq -0x18(%rbp), %rax
orq -0x28(%rbp), %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x22279
movzbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0x22258
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x1d2d0
movzbl %al, %eax
movl %eax, -0x50(%rbp)
jmp 0x22273
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1d2d0
movzbl %al, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x222ee
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x40(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
jne 0x22330
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x2236e
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e430
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x48(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
je 0x2236e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
jne 0x22354
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
je 0x22362
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x22419
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e470
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e470
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
movzbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
je 0x223d2
movzbl -0x31(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
je 0x223c5
movq -0x10(%rbp), %rax
orq -0x20(%rbp), %rax
shlq %rax
orq -0x18(%rbp), %rax
orq -0x28(%rbp), %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x22419
movzbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0x223f8
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x19d70
movzbl %al, %eax
movl %eax, -0x50(%rbp)
jmp 0x22413
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x19d70
movzbl %al, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x2248e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e430
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x38(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
jne 0x224d0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e450
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x2250b
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e430
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e410
movq %rax, %rcx
movq -0x40(%rbp), %rax
orq %rcx, %rax
cmpq $0x0, %rax
je 0x2250b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
jne 0x224f4
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
je 0x22502
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x1, -0x4(%rbp)
jmp 0x22512
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22610
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12be0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x225bb
movl $0x0, -0x1c(%rbp)
jmp 0x225da
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jle 0x225cf
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x225d8
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x225fa
jmp 0x225da
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x22630
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22610
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12750
movl %eax, -0x1c(%rbp)
cmpl $0xffff8000, -0x1c(%rbp) # imm = 0xFFFF8000
jge 0x2271d
movq $-0x8000, -0x28(%rbp)   # imm = 0x8000
jmp 0x2273c
cmpl $0x7fff, -0x1c(%rbp)    # imm = 0x7FFF
jle 0x22730
movq $0x7fff, -0x28(%rbp)    # imm = 0x7FFF
jmp 0x2273a
movslq -0x1c(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2275e
jmp 0x2273c
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x22630
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22610
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12750
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x227aa
movq $0x0, -0x28(%rbp)
jmp 0x227c9
cmpl $0xffff, -0x1c(%rbp)    # imm = 0xFFFF
jle 0x227bd
movq $0xffff, -0x28(%rbp)    # imm = 0xFFFF
jmp 0x227c7
movslq -0x1c(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x227eb
jmp 0x227c9
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x22630
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22610
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x13270
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x2283c
movq $0x0, -0x28(%rbp)
jmp 0x2285c
cmpq $0xffff, -0x20(%rbp)    # imm = 0xFFFF
jle 0x22850
movq $0xffff, -0x28(%rbp)    # imm = 0xFFFF
jmp 0x2285a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2287e
jmp 0x2285c
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x22630
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22610
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22910
movq %rax, -0x20(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x20(%rbp)
jbe 0x228d1
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x228da
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x228fa
movl -0x28(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x22630
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11610
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x116a0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11680
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x229a0
cmpq $0x3fe, -0x28(%rbp)     # imm = 0x3FE
jle 0x229a0
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x10(%rbp), %rdi
callq 0x22cd0
cmpl $0x0, %eax
je 0x22993
movq $-0x1, -0x8(%rbp)
jmp 0x22a41
movq $0x0, -0x8(%rbp)
jmp 0x22a41
cmpq $0x0, -0x28(%rbp)
je 0x229b9
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x433, %eax            # imm = 0x433
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jg 0x22a0d
movl $0x43e, %eax            # imm = 0x43E
cmpq -0x28(%rbp), %rax
jge 0x229f0
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq $-0x1, -0x8(%rbp)
jmp 0x22a41
movq $0x0, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %ecx
subq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
shlq %cl, %rax
movq %rax, -0x38(%rbp)
jmp 0x22a26
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x12ce0
movb -0x19(%rbp), %al
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rcx
movzbl %al, %edi
callq 0x130a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_uint32_round_to_zero
uint32 float64_to_uint32_round_to_zero(float64 a, float_status *status)
{
    uint64_t v;
    uint32 res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float64_to_uint64_round_to_zero(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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22610
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22ad0
movq %rax, -0x20(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x20(%rbp)
jbe 0x22a91
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x22a9a
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x22aba
movl -0x28(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x22630
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_uint64_round_to_zero
uint64_t float64_to_uint64_round_to_zero(float64 a, float_status *status)
{
    signed char current_rounding_mode = status->float_rounding_mode;
    set_float_rounding_mode(float_round_to_zero, status);
    int64_t v = float64_to_uint64(a, status);
    set_float_rounding_mode(current_rounding_mode, status);
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x13250
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22910
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x13250
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int16
int_fast16_t float64_to_int16(float64 a, float_status *status)
{
    int64_t v;
    int_fast16_t res;
    int old_exc_flags = get_float_exception_flags(status);

    v = float64_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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22610
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16830
cltq
movq %rax, -0x20(%rbp)
cmpq $-0x8000, -0x20(%rbp)   # imm = 0x8000
jge 0x22b63
movq $-0x8000, -0x28(%rbp)   # imm = 0x8000
jmp 0x22b83
cmpq $0x7fff, -0x20(%rbp)    # imm = 0x7FFF
jle 0x22b77
movq $0x7fff, -0x28(%rbp)    # imm = 0x7FFF
jmp 0x22b81
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22ba5
jmp 0x22b83
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x22630
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop