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

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

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

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

}

// Assembly:
movq %rsi, %r8
movabsq $0xfffffffffffff, %r9   # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rsi)
je 0xd05f
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
testq %rax, %rdi
setne %al
testq %r9, %rdi
sete %cl
orb %al, %cl
jne 0xd05f
orb $0x40, 0x2(%r8)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
incq %rax
andq %rax, %rdi
movq %rdi, %rax
andq %r9, %rax
movq %rdi, %rcx
shrq $0x34, %rcx
movl %ecx, %esi
andl $0x7ff, %esi            # imm = 0x7FF
leaq 0x1(%r9,%rax), %rdx
cmoveq %rax, %rdx
cmpq $0x433, %rsi            # imm = 0x433
jb 0xd0a3
cmpl $0x43f, %esi            # imm = 0x43F
jb 0xd0c1
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%r8)
testq %rdi, %rdi
js 0xd0fd
retq
cmpl $0x3f4, %esi            # imm = 0x3F4
jb 0xd0d4
addb $0xd, %cl
movq %rdx, %rax
shlq %cl, %rax
movb $0x33, %cl
subb %sil, %cl
shrq %cl, %rdx
movq %rdx, %rsi
jmp 0xd0ea
addq $-0x433, %rsi           # imm = 0xFBCD
movl %esi, %ecx
shlq %cl, %rdx
movq %rdx, %rsi
xorl %edx, %edx
jmp 0xd0ed
cmpl $0x3f3, %esi            # imm = 0x3F3
jne 0xd0e0
xorl %esi, %esi
jmp 0xd0ed
xorl %eax, %eax
testq %rdx, %rdx
setne %al
xorl %esi, %esi
movq %rax, %rdx
shrq $0x3f, %rdi
movzbl %dil, %edi
movq %r8, %rcx
jmp 0xa771
incq %r9
leaq 0x1(%rax), %rcx
cmpq %r9, %rdx
cmoveq %rcx, %rax
cmpl $0x7ff, %esi            # imm = 0x7FF
cmovneq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int64_round_to_zero
int64 float64_to_int64_round_to_zero(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig;
    int64 z;
    a = float64_squash_input_denormal(a, status);

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

}

// Assembly:
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rsi)
je 0xd154
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
testq %rax, %rdi
setne %al
testq %rcx, %rdi
sete %dl
orb %al, %dl
jne 0xd154
orb $0x40, 0x2(%rsi)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
incq %rax
andq %rax, %rdi
movq %rdi, %rax
andq %rcx, %rax
movq %rdi, %r8
shrq $0x34, %r8
andl $0x7ff, %r8d            # imm = 0x7FF
leaq 0x1(%rcx,%rax), %rdx
cmoveq %rax, %rdx
leaq -0x433(%r8), %rax
cmpq $0x433, %r8             # imm = 0x433
jb 0xd1a7
cmpl $0x43e, %r8d            # imm = 0x43E
jb 0xd1bc
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movabsq $-0x3c20000000000000, %r9 # imm = 0xC3E0000000000000
cmpq %r9, %rdi
jne 0xd1ed
incq %rax
retq
cmpl $0x3fd, %r8d            # imm = 0x3FD
ja 0xd1c6
orq %r8, %rdx
je 0xd1b9
orb $0x20, 0x2(%rsi)
xorl %eax, %eax
retq
movl %eax, %ecx
shlq %cl, %rdx
movq %rdx, %r8
jmp 0xd1df
movb $0x33, %cl
subb %r8b, %cl
movq %rdx, %r8
shrq %cl, %r8
movl %eax, %ecx
shlq %cl, %rdx
testq %rdx, %rdx
je 0xd1df
orb $0x20, 0x2(%rsi)
movq %r8, %rax
negq %rax
testq %rdi, %rdi
cmovnsq %r8, %rax
retq
orb $0x1, 0x2(%rsi)
testq %rdi, %rdi
jns 0xd1ec
cmpl $0x7ff, %r8d            # imm = 0x7FF
sete %sil
incq %rcx
cmpq %rcx, %rdx
setne %cl
testb %cl, %sil
je 0xd1a3
jmp 0xd1ec
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float16_to_float32
float32 float16_to_float32(float16 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;

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

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

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

// Assembly:
movl %edi, %eax
shrl $0xf, %eax
movl %edi, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %edi, %r8d
andl $0x3ff, %r8d            # imm = 0x3FF
cmpw $0x1f, %cx
setne %r9b
testl %esi, %esi
sete %sil
orb %r9b, %sil
jne 0xd290
testl %r8d, %r8d
je 0xd29a
movzwl %di, %ecx
movl %ecx, %esi
andl $0x7e00, %esi           # imm = 0x7E00
cmpl $0x7c00, %esi           # imm = 0x7C00
setne %sil
testl $0x1ff, %ecx            # imm = 0x1FF
sete %dil
orb %sil, %dil
jne 0xd268
orb $0x1, 0x2(%rdx)
shlq $0x36, %rcx
movq %rcx, %rsi
shrq $0x29, %rsi
shll $0x1f, %eax
cmpb $0x0, 0x6(%rdx)
leal 0x7f800000(%rax,%rsi), %eax
movl $0x7fc00000, %edx       # imm = 0x7FC00000
cmovnel %edx, %eax
testq %rcx, %rcx
cmovel %edx, %eax
retq
testw %cx, %cx
je 0xd2a3
movzwl %cx, %ecx
jmp 0xd2bc
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
retq
testl %r8d, %r8d
je 0xd2d1
bsrl %r8d, %edx
xorl $0x1f, %edx
leal -0x15(%rdx), %ecx
shll %cl, %r8d
movl $0x15, %ecx
subl %edx, %ecx
shll $0xd, %r8d
shll $0x1f, %eax
addl %r8d, %eax
shll $0x17, %ecx
addl %ecx, %eax
addl $0x38000000, %eax       # imm = 0x38000000
retq
shll $0x1f, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_float16
float16 float32_to_float16(float32 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;

    a = float32_squash_input_denormal(a, status);

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

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

// Assembly:
movq %rdx, %r8
cmpb $0x0, 0x5(%rdx)
je 0xd2ff
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xd2ff
orb $0x40, 0x2(%r8)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %edi, %r9d
shrl $0x17, %r9d
movl $0xff, %ecx
andl %ecx, %r9d
movl %edi, %eax
shrl $0x1f, %eax
cmpl %ecx, %r9d
jne 0xd372
testl %edx, %edx
je 0xd398
testb %sil, %sil
je 0xd3a6
movl %edi, %ecx
andl $0x7fc00000, %ecx       # imm = 0x7FC00000
cmpl $0x7f800000, %ecx       # imm = 0x7F800000
setne %cl
testl $0x3fffff, %edi         # imm = 0x3FFFFF
sete %dl
orb %cl, %dl
jne 0xd34c
orb $0x1, 0x2(%r8)
shrl $0xd, %edi
andl $0x3ff, %edi            # imm = 0x3FF
shll $0xf, %eax
cmpb $0x0, 0x6(%r8)
leal 0x7c00(%rax,%rdi), %eax
movl $0xfe00, %ecx           # imm = 0xFE00
cmovnel %ecx, %eax
testl %edi, %edi
cmovel %ecx, %eax
retq
movl %r9d, %ecx
orl %edx, %ecx
je 0xd3ab
pushq %rax
orl $0x800000, %edx         # imm = 0x800000
addq $-0x71, %r9
movzbl %al, %edi
movzbl %sil, %ecx
movq %r9, %rsi
callq 0xd3bd
addq $0x8, %rsp
retq
testb %sil, %sil
je 0xd3af
shll $0xf, %eax
orl $0x7c00, %eax           # imm = 0x7C00
retq
orb $0x1, 0x2(%r8)
shll $0xf, %eax
retq
orb $0x1, 0x2(%r8)
shll $0xf, %eax
orl $0x7fff, %eax           # imm = 0x7FFF
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float16_to_float64
float64 float16_to_float64(float16 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;

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

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

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

// Assembly:
movl %edi, %eax
shrl $0xf, %eax
movl %edi, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %edi, %r8d
andl $0x3ff, %r8d            # imm = 0x3FF
cmpw $0x1f, %cx
setne %r9b
testl %esi, %esi
sete %sil
orb %r9b, %sil
jne 0xd5c0
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testl %r8d, %r8d
je 0xd5ca
movzwl %di, %esi
movl %esi, %edi
andl $0x7e00, %edi           # imm = 0x7E00
cmpl $0x7c00, %edi           # imm = 0x7C00
setne %dil
testl $0x1ff, %esi            # imm = 0x1FF
sete %r8b
orb %dil, %r8b
jne 0xd591
orb $0x1, 0x2(%rdx)
shlq $0x36, %rsi
movq %rsi, %rdi
shrq $0xc, %rdi
shlq $0x3f, %rax
orq %rdi, %rax
orq %rcx, %rax
cmpb $0x0, 0x6(%rdx)
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
cmovneq %rcx, %rax
testq %rsi, %rsi
cmoveq %rcx, %rax
retq
testw %cx, %cx
je 0xd5d2
movzwl %cx, %ecx
jmp 0xd5ee
shlq $0x3f, %rax
orq %rcx, %rax
retq
testl %r8d, %r8d
je 0xd611
bsrl %r8d, %edx
xorl $0x1f, %edx
leal -0x15(%rdx), %ecx
shll %cl, %r8d
movl $0x15, %ecx
subl %edx, %ecx
movslq %ecx, %rcx
shlq $0x2a, %r8
shlq $0x3f, %rax
addq %r8, %rax
shlq $0x34, %rcx
movabsq $0x3f00000000000000, %rdx # imm = 0x3F00000000000000
addq %rax, %rdx
addq %rcx, %rdx
movq %rdx, %rax
retq
shlq $0x3f, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_float16
float16 float64_to_float16(float64 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig;
    uint32_t zSig;

    a = float64_squash_input_denormal(a, status);

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

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

// Assembly:
movq %rdx, %r8
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rdx)
je 0xd655
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
testq %rax, %rdi
setne %al
testq %rcx, %rdi
sete %dl
orb %al, %dl
jne 0xd655
orb $0x40, 0x2(%r8)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %rdi
andq %rdi, %rcx
movq %rdi, %r9
shrq $0x34, %r9
movl $0x7ff, %edx            # imm = 0x7FF
andq %rdx, %r9
movq %rdi, %rax
shrq $0x3f, %rax
cmpq %rdx, %r9
jne 0xd6dd
testq %rcx, %rcx
je 0xd717
testb %sil, %sil
je 0xd725
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
andq %rdi, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
setne %cl
movq %rdi, %rdx
shlq $0xd, %rdx
sete %dl
orb %cl, %dl
jne 0xd6b5
orb $0x1, 0x2(%r8)
shrq $0x2a, %rdi
andl $0x3ff, %edi            # imm = 0x3FF
shll $0xf, %eax
cmpb $0x0, 0x6(%r8)
leal 0x7c00(%rax,%rdi), %eax
movl $0xfe00, %ecx           # imm = 0xFE00
cmovnel %ecx, %eax
testq %rdi, %rdi
cmovel %ecx, %eax
retq
shrq $0x1d, %rcx
xorl %edx, %edx
shlq $0x23, %rdi
setne %dl
orq %rcx, %rdx
movq %rdx, %rcx
orq %r9, %rcx
je 0xd72a
pushq %rax
orl $0x800000, %edx         # imm = 0x800000
addq $-0x3f1, %r9            # imm = 0xFC0F
movzbl %al, %edi
movzbl %sil, %ecx
movq %r9, %rsi
callq 0xd3bd
addq $0x8, %rsp
retq
testb %sil, %sil
je 0xd72e
shll $0xf, %eax
orl $0x7c00, %eax           # imm = 0x7C00
retq
orb $0x1, 0x2(%r8)
shll $0xf, %eax
retq
orb $0x1, 0x2(%r8)
shll $0xf, %eax
orl $0x7fff, %eax           # imm = 0x7FFF
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_floatx80
floatx80 float64_to_floatx80(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig;

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

}

// Assembly:
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movabsq $0xfffffffffffff, %rdx  # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rsi)
je 0xd779
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testq %rcx, %rdi
setne %cl
testq %rdx, %rdi
sete %r8b
orb %cl, %r8b
jne 0xd779
orb $0x40, 0x2(%rsi)
andq %rax, %rdi
andq %rdi, %rdx
movq %rdi, %r9
shrq $0x34, %r9
movq %rdi, %r8
shrq $0x3f, %r8
andq $0x7ff, %r9             # imm = 0x7FF
je 0xd81a
cmpl $0x7ff, %r9d            # imm = 0x7FF
jne 0xd83b
testq %rdx, %rdx
je 0xd854
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
andq %rdi, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
setne %cl
movq %rdi, %rdx
shlq $0xd, %rdx
sete %dl
orb %cl, %dl
jne 0xd7dc
orb $0x1, 0x2(%rsi)
shlq $0xc, %rdi
cmpb $0x0, 0x6(%rsi)
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
shrq %rdi
orq %rax, %rdi
shll $0xf, %r8d
orl $0x7fff, %r8d           # imm = 0x7FFF
testb %dl, %dl
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
cmoveq %rdi, %rax
movl $0xffff, %edx           # imm = 0xFFFF
cmovel %r8d, %edx
retq
testq %rdx, %rdx
je 0xd861
bsrq %rdx, %rcx
xorl $0x3f, %ecx
addl $0xf5, %ecx
movzbl %cl, %ecx
shlq %cl, %rdx
movl $0x1, %r9d
subl %ecx, %r9d
shlq $0xb, %rdx
orq %rdx, %rax
movzwl %r8w, %ecx
shll $0xf, %ecx
leal (%r9,%rcx), %edx
addl $0x3c00, %edx           # imm = 0x3C00
retq
shll $0xf, %r8d
orl $0x7fff, %r8d           # imm = 0x7FFF
jmp 0xd867
shll $0xf, %r8d
xorl %eax, %eax
movl %r8d, %edx
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_float128
float128 float64_to_float128(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig, zSig0, zSig1;

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

}

// Assembly:
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rsi)
je 0xd8a8
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testq %rcx, %rdi
setne %cl
testq %rax, %rdi
sete %r8b
orb %cl, %r8b
jne 0xd8a8
orb $0x40, 0x2(%rsi)
andq %rdx, %rdi
andq %rdi, %rax
movq %rdi, %rcx
shrq $0x34, %rcx
andq %rdi, %rdx
andq $0x7ff, %rcx            # imm = 0x7FF
je 0xd910
cmpl $0x7ff, %ecx            # imm = 0x7FF
jne 0xd92d
testq %rax, %rax
je 0xd953
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
andq %rdi, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
setne %al
movq %rdi, %rcx
shlq $0xd, %rcx
sete %cl
orb %al, %cl
jne 0xd8fe
orb $0x1, 0x2(%rsi)
cmpb $0x0, 0x6(%rsi)
je 0xd966
movabsq $0x7fff800000000000, %rdx # imm = 0x7FFF800000000000
jmp 0xd950
testq %rax, %rax
je 0xd950
bsrq %rax, %rcx
xorl $0x3f, %ecx
addl $0xf5, %ecx
movzbl %cl, %ecx
shlq %cl, %rax
negl %ecx
movslq %ecx, %rcx
movq %rax, %rsi
shrq $0x4, %rsi
shlq $0x3c, %rax
shlq $0x30, %rcx
addq %rdx, %rsi
movabsq $0x3c00000000000000, %rdx # imm = 0x3C00000000000000
addq %rcx, %rdx
addq %rsi, %rdx
retq
xorl %eax, %eax
retq
movabsq $0x7fff000000000000, %rax # imm = 0x7FFF000000000000
orq %rax, %rdi
xorl %eax, %eax
movq %rdi, %rdx
retq
movq %rdi, %rax
shrq $0x4, %rax
shlq $0x3c, %rdi
movabsq $0x7fff000000000000, %rcx # imm = 0x7FFF000000000000
orq %rax, %rcx
orq %rcx, %rdx
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: propagateFloat64NaN
static float64 propagateFloat64NaN(float64 a, float64 b, float_status *status)
{
    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    flag aIsLargerSignificand;
    uint64_t av, bv;

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

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

    if (status->default_nan_mode)
        return float64_default_nan;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movq %rdi, %r8
andq %rax, %r8
cmpq %rcx, %r8
sete %r9b
movq %rdi, %r10
shlq $0xd, %r10
setne %r11b
andb %r9b, %r11b
movq %rsi, %r9
andq %rax, %r9
cmpq %rcx, %r9
sete %bl
movq %rsi, %r10
shlq $0xd, %r10
setne %r10b
andb %bl, %r10b
movl %r11d, %ebx
orb %r10b, %bl
cmpb $0x1, %bl
jne 0xdb83
orb $0x1, 0x2(%rdx)
cmpb $0x0, 0x6(%rdx)
jne 0xdc24
leaq (%rdi,%rdi), %r14
leaq (%rsi,%rsi), %rax
cmpq %rax, %r14
jae 0xdb9e
xorl %ebx, %ebx
jmp 0xdba8
movb $0x1, %bl
ja 0xdba8
cmpq %rsi, %rdi
setb %bl
movabsq $-0x10000000000001, %r15 # imm = 0xFFEFFFFFFFFFFFFF
movabsq $0x7ffffffffffff, %rdx  # imm = 0x7FFFFFFFFFFFF
testb %r11b, %r11b
je 0xdbdb
xorl %r11d, %r11d
cmpq %r15, %rax
seta %r11b
xorl %eax, %eax
testb %bl, %bl
sete %al
testb %r10b, %r10b
cmovel %r11d, %eax
jmp 0xdbf4
leaq 0x1(%r15), %r11
cmpq %r11, %r14
jb 0xdbf8
cmpq %r15, %rax
seta %r11b
orb %r10b, %bl
sete %al
andb %r11b, %al
testb %al, %al
je 0xdc0f
leaq 0x1(%rdx), %rax
orq %rsi, %rax
testq %rdx, %rsi
cmoveq %rsi, %rax
cmpq %rcx, %r9
cmovneq %rsi, %rax
jmp 0xdc24
leaq 0x1(%rdx), %rax
orq %rdi, %rax
testq %rdx, %rdi
cmoveq %rdi, %rax
cmpq %rcx, %r8
cmovneq %rdi, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_trunc_to_int
float64 float64_trunc_to_int(float64 a, float_status *status)
{
    int oldmode;
    float64 res;
    oldmode = status->float_rounding_mode;
    status->float_rounding_mode = float_round_to_zero;
    res = float64_round_to_int(a, status);
    status->float_rounding_mode = oldmode;
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x1(%rsi), %bpl
movb $0x3, 0x1(%rsi)
callq 0xd985
movb %bpl, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift128RightJamming
static inline void
 shift128RightJamming(
     uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
{
    uint64_t z0, z1;
    int8 negCount = ( - count ) & 63;

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

}

// Assembly:
movq %rcx, %rax
testq %rdx, %rdx
je 0xedb5
movl %edx, %r9d
negb %r9b
andb $0x3f, %r9b
cmpq $0x3f, %rdx
jg 0xed74
movq %rdi, %r10
movl %r9d, %ecx
shlq %cl, %r10
movq %rsi, %r11
movl %edx, %ecx
shrq %cl, %r11
orq %r10, %r11
movl %r9d, %ecx
shlq %cl, %rsi
xorl %r9d, %r9d
testq %rsi, %rsi
setne %r9b
orq %r11, %r9
movl %edx, %ecx
shrq %cl, %rdi
movq %r9, %rsi
jmp 0xedb5
cmpq $0x40, %rdx
jne 0xed87
xorl %ecx, %ecx
testq %rsi, %rsi
setne %cl
orq %rdi, %rcx
jmp 0xedb0
cmpq $0x7f, %rdx
jg 0xeda8
movq %rdi, %r10
movl %edx, %ecx
shrq %cl, %r10
movl %r9d, %ecx
shlq %cl, %rdi
xorl %ecx, %ecx
orq %rsi, %rdi
setne %cl
orq %r10, %rcx
jmp 0xedb0
xorl %ecx, %ecx
orq %rdi, %rsi
setne %cl
xorl %edi, %edi
movq %rcx, %rsi
movq %rsi, (%r8)
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_eq
int float64_eq(float64 a, float64 b, float_status *status)
{
    uint64_t av, bv;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

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

}

// Assembly:
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
movb 0x5(%rdx), %r8b
testb %r8b, %r8b
je 0xf173
testq %rcx, %rdi
setne %r9b
testq %rax, %rdi
sete %r10b
orb %r9b, %r10b
jne 0xf173
orb $0x40, 0x2(%rdx)
movabsq $-0x8000000000000000, %r9 # imm = 0x8000000000000000
andq %r9, %rdi
testb %r8b, %r8b
je 0xf19c
testq %rcx, %rsi
setne %r8b
testq %rax, %rsi
sete %r9b
orb %r8b, %r9b
jne 0xf19c
orb $0x40, 0x2(%rdx)
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
andq %r8, %rsi
movq %rdi, %r8
notq %r8
testq %r8, %rcx
sete %r8b
testq %rax, %rdi
setne %r9b
testb %r9b, %r8b
jne 0xf1ed
movq %rsi, %r8
notq %r8
testq %r8, %rcx
setne %cl
testq %rax, %rsi
sete %al
orb %cl, %al
je 0xf1ed
cmpq %rsi, %rdi
sete %al
orq %rdi, %rsi
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
decq %rcx
testq %rcx, %rsi
sete %cl
orb %al, %cl
movzbl %cl, %eax
retq
orb $0x1, 0x2(%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_le
int float64_le(float64 a, float64 b, float_status *status)
{
    flag aSign, bSign;
    uint64_t av, bv;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

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

}

// Assembly:
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
movb 0x5(%rdx), %r8b
testb %r8b, %r8b
je 0xf235
testq %rcx, %rdi
setne %r9b
testq %rax, %rdi
sete %r10b
orb %r9b, %r10b
jne 0xf235
orb $0x40, 0x2(%rdx)
movabsq $-0x8000000000000000, %r9 # imm = 0x8000000000000000
andq %r9, %rdi
testb %r8b, %r8b
je 0xf25e
testq %rcx, %rsi
setne %r8b
testq %rax, %rsi
sete %r9b
orb %r8b, %r9b
jne 0xf25e
orb $0x40, 0x2(%rdx)
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
andq %r8, %rsi
movq %rdi, %r8
notq %r8
testq %r8, %rcx
sete %r8b
testq %rax, %rdi
setne %r9b
testb %r9b, %r8b
jne 0xf2a8
movq %rsi, %r8
notq %r8
testq %r8, %rcx
setne %cl
testq %rax, %rsi
sete %al
orb %cl, %al
je 0xf2a8
movq %rsi, %rax
xorq %rdi, %rax
js 0xf2b0
cmpq %rsi, %rdi
sete %cl
setb %dl
testq %rdi, %rdi
sets %al
xorb %dl, %al
jmp 0xf2cc
orb $0x1, 0x2(%rdx)
xorl %eax, %eax
jmp 0xf2ce
testq %rdi, %rdi
sets %cl
orq %rdi, %rsi
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
decq %rax
testq %rax, %rsi
sete %al
orb %cl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_unordered
int float64_unordered(float64 a, float64 b, float_status *status)
{
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

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

// Assembly:
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
movb 0x5(%rdx), %r8b
testb %r8b, %r8b
je 0xf3e6
testq %rcx, %rdi
setne %r9b
testq %rax, %rdi
sete %r10b
orb %r9b, %r10b
jne 0xf3e6
orb $0x40, 0x2(%rdx)
xorl %edi, %edi
testb %r8b, %r8b
je 0xf404
testq %rcx, %rsi
setne %r8b
testq %rax, %rsi
sete %r9b
orb %r8b, %r9b
jne 0xf404
orb $0x40, 0x2(%rdx)
xorl %esi, %esi
movq %rdi, %r8
notq %r8
testq %r8, %rcx
sete %r8b
testq %rax, %rdi
setne %dil
testb %dil, %r8b
jne 0xf437
movq %rsi, %rdi
notq %rdi
testq %rdi, %rcx
setne %cl
testq %rax, %rsi
sete %sil
xorl %eax, %eax
orb %cl, %sil
jne 0xf440
orb $0x1, 0x2(%rdx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_unordered_quiet
int float64_unordered_quiet(float64 a, float64 b, float_status *status)
{
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

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

// Assembly:
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
movb 0x5(%rdx), %r8b
testb %r8b, %r8b
je 0xf7c3
testq %rcx, %rdi
setne %r9b
testq %rax, %rdi
sete %r10b
orb %r9b, %r10b
jne 0xf7c3
orb $0x40, 0x2(%rdx)
xorl %edi, %edi
testb %r8b, %r8b
je 0xf7e1
testq %rcx, %rsi
setne %r8b
testq %rax, %rsi
sete %r9b
orb %r8b, %r9b
jne 0xf7e1
orb $0x40, 0x2(%rdx)
xorl %esi, %esi
movq %rdi, %r8
notq %r8
testq %r8, %rcx
sete %r8b
testq %rax, %rdi
setne %r9b
testb %r9b, %r8b
jne 0xf815
movq %rsi, %r8
notq %r8
testq %r8, %rcx
setne %r8b
testq %rax, %rsi
sete %r9b
xorl %eax, %eax
orb %r8b, %r9b
jne 0xf864
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rdi, %r8
andq %rax, %r8
cmpq %rcx, %r8
sete %r8b
shlq $0xd, %rdi
setne %dil
testb %dil, %r8b
jne 0xf85b
movabsq $0x7ffffffffffff, %rdi  # imm = 0x7FFFFFFFFFFFF
andq %rsi, %rax
cmpq %rcx, %rax
setne %al
testq %rdi, %rsi
sete %cl
orb %al, %cl
movl $0x1, %eax
jne 0xf864
orb $0x1, 0x2(%rdx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int32
int32 floatx80_to_int32(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig;

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

}

// Assembly:
movl %esi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movzwl %ax, %r8d
cmpl $0x3ff8, %eax           # imm = 0x3FF8
jb 0xf8a5
movl $0x4037, %eax           # imm = 0x4037
subl %r8d, %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movq %rdi, %r9
shrq %cl, %r9
negb %cl
movq %rdi, %r10
shlq %cl, %r10
xorl %eax, %eax
testq %r10, %r10
setne %al
orq %r9, %rax
jmp 0xf8ad
xorl %eax, %eax
testq %rdi, %rdi
setne %al
shlq %rdi
movzwl %si, %esi
shrl $0xf, %esi
xorl %ecx, %ecx
testq %rdi, %rdi
cmovel %esi, %ecx
cmpl $0x7fff, %r8d           # imm = 0x7FFF
cmovnel %esi, %ecx
movl %ecx, %edi
movq %rax, %rsi
jmp 0xa4bf
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int32_round_to_zero
int32 floatx80_to_int32_round_to_zero(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig, savedASig;
    int32_t z;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    if ( 0x401E < aExp ) {
        if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
        goto invalid;
    }
    else if ( aExp < 0x3FFF ) {
        if (aExp || aSig) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    shiftCount = 0x403E - aExp;
    savedASig = aSig;
    aSig >>= shiftCount;
    z = aSig;
    if ( aSign ) z = - z;
    if ( ( z < 0 ) ^ aSign ) {
 invalid:
        float_raise(float_flag_invalid, status);
        return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
    }
    if ( ( aSig<<shiftCount ) != savedASig ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;

}

// Assembly:
movzwl %si, %r8d
movl %esi, %r9d
andl $0x7fff, %r9d           # imm = 0x7FFF
shrl $0xf, %r8d
cmpl $0x401f, %r9d           # imm = 0x401F
jb 0xf91a
shlq %rdi
movzbl %r8b, %eax
xorl %r8d, %r8d
testq %rdi, %rdi
cmovel %eax, %r8d
cmpl $0x7fff, %r9d           # imm = 0x7FFF
cmovnel %eax, %r8d
orb $0x1, 0x2(%rdx)
cmpb $0x1, %r8b
movl $0x80000000, %eax       # imm = 0x80000000
sbbl $0x0, %eax
retq
cmpl $0x3ffe, %r9d           # imm = 0x3FFE
ja 0xf92f
xorl %eax, %eax
orq %r9, %rdi
je 0xf92e
orb $0x20, 0x2(%rdx)
retq
movl $0x403e, %ecx           # imm = 0x403E
subl %r9d, %ecx
movq %rdi, %r9
shrq %cl, %r9
movl %r9d, %eax
negl %eax
testw %si, %si
cmovnsl %r9d, %eax
movl %eax, %esi
shrl $0x1f, %esi
movzwl %r8w, %r10d
cmpl %r10d, %esi
jne 0xf909
shlq %cl, %r9
cmpq %rdi, %r9
jne 0xf92a
jmp 0xf92e
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int64
int64 floatx80_to_int64(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig, aSigExtra;

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

}

// Assembly:
movq %rdx, %r8
movq %rdi, %rdx
movl %esi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movzwl %ax, %ecx
cmpl $0x403e, %eax           # imm = 0x403E
jb 0xf987
cmpl $0x403e, %ecx           # imm = 0x403E
jne 0xf9aa
movq %rdx, %rcx
xorl %edx, %edx
jmp 0xf9d8
movl $0x403e, %eax           # imm = 0x403E
subl %ecx, %eax
cmpl $0x3f, %eax
ja 0xf9bf
movl %eax, %ecx
negb %cl
movq %rdx, %rdi
shlq %cl, %rdi
movl %eax, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rdi, %rdx
jmp 0xf9d8
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%r8)
testw %si, %si
js 0xf9ec
retq
cmpl $0x3ffe, %ecx           # imm = 0x3FFE
jne 0xf9cb
xorl %ecx, %ecx
jmp 0xf9d8
xorl %eax, %eax
testq %rdx, %rdx
setne %al
xorl %ecx, %ecx
movq %rax, %rdx
movzwl %si, %eax
shrl $0xf, %eax
movzbl %al, %edi
movq %rcx, %rsi
movq %r8, %rcx
jmp 0xa771
leaq 0x1(%rax), %rsi
cmpq %rsi, %rdx
cmoveq %rsi, %rax
cmpl $0x7fff, %ecx           # imm = 0x7FFF
cmovneq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int64_round_to_zero
int64 floatx80_to_int64_round_to_zero(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig;
    int64 z;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    shiftCount = aExp - 0x403E;
    if ( 0 <= shiftCount ) {
        aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );
        if ( ( a.high != 0xC03E ) || aSig ) {
            float_raise(float_flag_invalid, status);
            if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
                return LIT64( 0x7FFFFFFFFFFFFFFF );
            }
        }
        return (int64_t) LIT64( 0x8000000000000000 );
    }
    else if ( aExp < 0x3FFF ) {
        if (aExp | aSig) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    z = aSig>>( - shiftCount );
    if ( (uint64_t) ( aSig<<( shiftCount & 63 ) ) ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    if ( aSign ) z = - z;
    return z;

}

// Assembly:
movl %esi, %r8d
andl $0x7fff, %r8d           # imm = 0x7FFF
cmpl $0x403e, %r8d           # imm = 0x403E
jb 0xfa64
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movzwl %si, %ecx
cmpl $0xc03e, %ecx           # imm = 0xC03E
setne %cl
leaq (,%rdi,2), %r9
testq %r9, %r9
setne %r9b
orb %cl, %r9b
cmpb $0x1, %r9b
jne 0xfa60
testq %rax, %rdi
setne %cl
orb $0x1, 0x2(%rdx)
cmpl $0x7fff, %r8d           # imm = 0x7FFF
sete %dl
testw %si, %si
jns 0xfaa6
andb %cl, %dl
jne 0xfaa6
incq %rax
retq
cmpl $0x3ffe, %r8d           # imm = 0x3FFE
ja 0xfa7c
movl %r8d, %eax
orq %rdi, %rax
je 0xfa79
orb $0x20, 0x2(%rdx)
xorl %eax, %eax
retq
leal 0x2(%r8), %eax
movb $0x3e, %cl
subb %r8b, %cl
movq %rdi, %r8
shrq %cl, %r8
movl %eax, %ecx
shlq %cl, %rdi
testq %rdi, %rdi
je 0xfa99
orb $0x20, 0x2(%rdx)
movq %r8, %rax
negq %rax
testw %si, %si
cmovnsq %r8, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_float32
float32 floatx80_to_float32(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp;
    uint64_t aSig;

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

}

// Assembly:
movq %rdx, %rcx
movzwl %si, %eax
movl $0x7fff, %edx           # imm = 0x7FFF
andl %edx, %esi
shrl $0xf, %eax
cmpl %edx, %esi
jne 0xfb2d
leaq (,%rdi,2), %rdx
testq %rdx, %rdx
je 0xfb65
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
leaq (,%rdi,4), %rsi
testq %rsi, %rsi
je 0xfaf9
movabsq $0x3fffffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFFFF
incq %rsi
andq %rdi, %rsi
jne 0xfaf9
orb $0x1, 0x2(%rcx)
leaq (%rdi,%rdi), %rsi
incq %rdx
shll $0x1f, %eax
testq %rdi, %rdi
cmovsq %rsi, %rdx
movl $0x80000000, %esi       # imm = 0x80000000
cmovsl %eax, %esi
shrq $0x29, %rdx
leal 0x7f800000(%rsi,%rdx), %eax
movl $0x7fc00000, %edx       # imm = 0x7FC00000
cmovel %edx, %eax
cmpb $0x0, 0x6(%rcx)
cmovnel %edx, %eax
retq
movzwl %si, %r8d
movq %rdi, %rsi
shrq $0x21, %rsi
xorl %edx, %edx
shlq $0x1f, %rdi
setne %dl
orq %rsi, %rdx
leaq -0x3f81(%r8), %rdi
testq %rdx, %rdx
movq %rdi, %rsi
cmoveq %rdx, %rsi
testw %r8w, %r8w
cmovneq %rdi, %rsi
movzwl %ax, %edi
jmp 0x9e9b
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: 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 0xfc0e
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
leaq -0x1(%rsi), %r8
testq %r8, %rax
je 0xfc3f
leaq (,%rax,4), %r8
testq %r8, %r8
je 0xfbcd
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
incq %r8
andq %rax, %r8
jne 0xfbcd
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 0xa1a9
movzwl %di, %eax
shlq $0x3f, %rax
orq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfca7
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
leaq -0x1(%rdi), %r8
andq %rax, %r8
je 0xfca7
leaq (,%rax,4), %rsi
testq %rsi, %rsi
je 0xfc94
movabsq $0x3fffffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFFFF
incq %rsi
andq %rax, %rsi
jne 0xfc94
orb $0x1, 0x2(%rdx)
cmpb $0x0, 0x6(%rdx)
je 0xfcd2
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 0xfd00
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_O1/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 $0x7fff, %eax           # imm = 0x7FFF
movl %esi, %r10d
andl %eax, %r10d
cmpl %eax, %r10d
sete %bpl
leaq 0x1(%r9), %r11
testq %r11, %rdi
setne %r15b
sete %r13b
leaq (,%rdi,4), %r9
testq %r9, %r9
setne %r9b
andb %bpl, %r13b
andb %r9b, %r13b
movl %ecx, %ebx
andl %eax, %ebx
cmpl %eax, %ebx
sete %r14b
testq %r11, %rdx
setne %r9b
sete %r12b
leaq (,%rdx,4), %rax
testq %rax, %rax
setne %al
andb %r14b, %r12b
andb %al, %r12b
testb %r13b, %r13b
jne 0xff48
testb %r12b, %r12b
je 0xff4d
orb $0x1, 0x2(%r8)
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
cmpb $0x0, 0x6(%r8)
je 0xff67
movw $0xffff, %cx            # imm = 0xFFFF
jmp 0x1001d
cmpq %rdx, %rdi
jae 0xff71
xorl %r8d, %r8d
jmp 0xff7d
movb $0x1, %r8b
ja 0xff7d
cmpw %cx, %si
setb %r8b
andb %r9b, %r14b
testb %r13b, %r13b
je 0xff9c
xorl %r9d, %r9d
testb %r8b, %r8b
sete %r9b
movzbl %r14b, %r8d
testb %r12b, %r12b
cmovel %r8d, %r9d
jmp 0xffae
andb %r15b, %bpl
je 0xffb3
orb %r12b, %r8b
sete %r8b
andb %r8b, %r14b
movl %r14d, %r9d
testb %r9b, %r9b
je 0xffe8
testq %r11, %rdx
setne %sil
movabsq $0x3fffffffffffffff, %rdi # imm = 0x3FFFFFFFFFFFFFFF
testq %rdi, %rdx
sete %dil
orb %sil, %dil
orq %rdx, %rax
testb $0x1, %dil
cmovneq %rdx, %rax
movzwl %bx, %esi
cmpl $0x7fff, %esi           # imm = 0x7FFF
cmovneq %rdx, %rax
jmp 0x1001d
testq %r11, %rdi
setne %cl
movzwl %r10w, %edx
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
testq %r8, %rdi
sete %r8b
orb %cl, %r8b
orq %rdi, %rax
testb $0x1, %r8b
cmovneq %rdi, %rax
cmpl $0x7fff, %edx           # imm = 0x7FFF
cmovneq %rdi, %rax
movl %esi, %ecx
movl %ecx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq