LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: uint64_to_float64
float64 uint64_to_float64(uint64_t a, float_status *status)
{
    int exp = 0x43C;
    int shiftcount;

    if (a == 0) {
        return float64_zero;
    }

    shiftcount = countLeadingZeros64(a) - 1;
    if (shiftcount < 0) {
        shift64RightJamming(a, -shiftcount, &a);
    } else {
        a <<= shiftcount;
    }
    return roundAndPackFloat64(0, exp - shiftcount, a, status);
}

// Assembly:
testq %rdi, %rdi
je 0xa241
movq %rsi, %rax
movq %rdi, %rdx
bsrq %rdi, %rdi
xorq $0x3f, %rdi
je 0xa244
leal -0x1(%rdi), %ecx
shlq %cl, %rdx
jmp 0xa250
xorl %eax, %eax
retq
movq %rdx, %rcx
shrq %rcx
andl $0x1, %edx
orq %rcx, %rdx
movl $0x43d, %esi            # imm = 0x43D
subq %rdi, %rsi
xorl %edi, %edi
movq %rax, %rcx
jmp 0xa25f
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: normalizeRoundAndPackFloat128
static float128 normalizeRoundAndPackFloat128(flag zSign, int32 zExp,
                                              uint64_t zSig0, uint64_t zSig1,
                                              float_status *status)
{
    int8 shiftCount;
    uint64_t zSig2;

    if ( zSig0 == 0 ) {
        zSig0 = zSig1;
        zSig1 = 0;
        zExp -= 64;
    }
    shiftCount = countLeadingZeros64( zSig0 ) - 15;
    if ( 0 <= shiftCount ) {
        zSig2 = 0;
        shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
    }
    else {
        shift128ExtraRightJamming(
            zSig0, zSig1, 0, - shiftCount, &zSig0, &zSig1, &zSig2 );
    }
    zExp -= shiftCount;
    return roundAndPackFloat128(zSign, zExp, zSig0, zSig1, zSig2, status);

}

// Assembly:
movq %r8, %r9
movq %rcx, %r11
movq %rdx, %rax
testq %rdx, %rdx
cmoveq %rcx, %rdx
cmoveq %rax, %r11
testq %rdx, %rdx
je 0xa42d
bsrq %rdx, %rcx
xorq $0x3f, %rcx
jmp 0xa432
movl $0x40, %ecx
pushq %r14
pushq %rbx
addb $-0xf, %cl
movsbl %cl, %ebx
movq %rdx, %r8
shrq $0x31, %r8
jne 0xa461
movq %r11, %r10
shlq %cl, %r10
testb %cl, %cl
je 0xa45c
movslq %ebx, %rcx
shlq %cl, %rdx
negb %cl
shrq %cl, %r11
orq %r11, %rdx
xorl %r8d, %r8d
jmp 0xa4b4
testb %cl, %cl
je 0xa494
movl %ebx, %r8d
negl %r8d
cmpl $0x3f, %r8d
ja 0xa49c
andb $0x3f, %cl
movq %r11, %r14
shlq %cl, %r14
movq %rdx, %r10
shlq %cl, %r10
movl %r8d, %ecx
shrq %cl, %r11
shrq %cl, %rdx
orq %r10, %r11
movq %r11, %r10
xorl %r11d, %r11d
jmp 0xa4a7
xorl %r8d, %r8d
movq %r11, %r10
jmp 0xa4b4
movl $0x1, %r14d
xorl %edx, %edx
xorl %r10d, %r10d
xorl %r8d, %r8d
testq %r11, %r11
setne %r8b
orq %r14, %r8
leal -0x40(%rsi), %ecx
testq %rax, %rax
cmovnel %esi, %ecx
subl %ebx, %ecx
movzbl %dil, %edi
movl %ecx, %esi
movq %r10, %rcx
popq %rbx
popq %r14
jmp 0x12ddf
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_int32
int32 float32_to_int32(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint32_t aSig;
    uint64_t aSig64;

    a = float32_squash_input_denormal(a, status);
    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );
    if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
    if ( aExp ) aSig |= 0x00800000;
    shiftCount = 0xAF - aExp;
    aSig64 = aSig;
    aSig64 <<= 32;
    if ( 0 < shiftCount ) shift64RightJamming( aSig64, shiftCount, &aSig64 );
    return roundAndPackInt32(aSign, aSig64, status);

}

// Assembly:
movq %rsi, %rdx
cmpb $0x0, 0x5(%rsi)
je 0xa4f9
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xa4f9
orb $0x40, 0x2(%rdx)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %r8d
andl $0x7fffff, %r8d         # imm = 0x7FFFFF
movl %edi, %eax
shrl $0x17, %eax
movzbl %al, %r9d
leal 0x800000(%r8), %eax
testl %r9d, %r9d
cmovel %r8d, %eax
movq %rax, %rsi
shlq $0x20, %rsi
cmpl $0xae, %r9d
ja 0xa55a
cmpl $0x70, %r9d
jb 0xa552
movb $-0x51, %cl
subb %r9b, %cl
movq %rsi, %rax
shrq %cl, %rax
leal 0x11(%r9), %ecx
shlq %cl, %rsi
xorl %ecx, %ecx
testq %rsi, %rsi
setne %cl
orq %rax, %rcx
movq %rcx, %rsi
jmp 0xa55a
xorl %esi, %esi
testl %eax, %eax
setne %sil
shrl $0x1f, %edi
xorl %eax, %eax
cmpl $0xff, %r9d
cmovnel %edi, %eax
testl %r8d, %r8d
cmovel %edi, %eax
movl %eax, %edi
jmp 0xa573
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: roundAndPackInt32
static int32 roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status)
{
    int8 roundingMode;
    flag roundNearestEven;
    int8 roundIncrement, roundBits;
    int32_t z;

    roundingMode = status->float_rounding_mode;
    roundNearestEven = ( roundingMode == float_round_nearest_even );
    switch (roundingMode) {
    case float_round_nearest_even:
    case float_round_ties_away:
        roundIncrement = 0x40;
        break;
    case float_round_to_zero:
        roundIncrement = 0;
        break;
    case float_round_up:
        roundIncrement = zSign ? 0 : 0x7f;
        break;
    case float_round_down:
        roundIncrement = zSign ? 0x7f : 0;
        break;
    default:
        abort();
    }
    roundBits = absZ & 0x7F;
    absZ = ( absZ + roundIncrement )>>7;
    absZ &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
    z = absZ;
    if ( zSign ) z = - z;
    if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
        float_raise(float_flag_invalid, status);
        return zSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
    }
    if (roundBits) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;

}

// Assembly:
movzbl 0x1(%rdx), %eax
cmpq $0x4, %rax
ja 0xa621
leaq 0xc220(%rip), %rcx      # 0x167a8
movslq (%rcx,%rax,4), %r8
addq %rcx, %r8
jmpq *%r8
movl $0x40, %ecx
jmp 0xa5bd
xorl %ecx, %ecx
jmp 0xa5bd
xorl %r8d, %r8d
testb %dil, %dil
movl $0x7f, %ecx
cmoveq %r8, %rcx
jmp 0xa5bd
xorl %r8d, %r8d
testb %dil, %dil
movl $0x7f, %ecx
cmovneq %r8, %rcx
movl %esi, %r8d
andb $0x7f, %r8b
addq %rsi, %rcx
movq %rcx, %rsi
shrq $0x7, %rsi
movl %r8d, %r9d
xorb $0x40, %r9b
xorl %r10d, %r10d
orb %al, %r9b
sete %r10b
notl %r10d
andl %r10d, %esi
movl %esi, %eax
negl %eax
testb %dil, %dil
cmovel %esi, %eax
shrq $0x27, %rcx
jne 0xa610
testl %eax, %eax
je 0xa606
movl %eax, %ecx
shrl $0x1f, %ecx
movzbl %dil, %esi
cmpl %esi, %ecx
jne 0xa610
testb %r8b, %r8b
je 0xa60f
orb $0x20, 0x2(%rdx)
retq
orb $0x1, 0x2(%rdx)
cmpb $0x1, %dil
movl $0x80000000, %eax       # imm = 0x80000000
sbbl $0x0, %eax
retq
pushq %rax
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_int32_round_to_zero
int32 float32_to_int32_round_to_zero(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint32_t aSig;
    int32_t z;
    a = float32_squash_input_denormal(a, status);

    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );
    shiftCount = aExp - 0x9E;
    if ( 0 <= shiftCount ) {
        if ( float32_val(a) != 0xCF000000 ) {
            float_raise(float_flag_invalid, status);
            if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
        }
        return (int32_t) 0x80000000;
    }
    else if ( aExp <= 0x7E ) {
        if (aExp | aSig) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    aSig = ( aSig | 0x00800000 )<<8;
    z = aSig>>( - shiftCount );
    if ( (uint32_t) ( aSig<<( shiftCount & 31 ) ) ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    if ( aSign ) z = - z;
    return z;

}

// Assembly:
cmpb $0x0, 0x5(%rsi)
je 0xa64d
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xa64d
orb $0x40, 0x2(%rsi)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %edi, %eax
shrl $0x17, %eax
movzbl %al, %ecx
cmpl $0x9e, %ecx
jb 0xa673
cmpl $0xcf000000, %edi       # imm = 0xCF000000
jne 0xa683
movl $0x80000000, %eax       # imm = 0x80000000
retq
cmpl $0x7e, %ecx
ja 0xa691
xorl %eax, %eax
orl %edx, %ecx
je 0xa690
orb $0x20, 0x2(%rsi)
retq
orb $0x1, 0x2(%rsi)
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
testl %edi, %edi
js 0xa6be
retq
shll $0x8, %edx
orl $0x80000000, %edx       # imm = 0x80000000
movb $-0x62, %cl
subb %al, %cl
movl %edx, %r8d
shrl %cl, %r8d
addb $0x2, %al
movl %eax, %ecx
shll %cl, %edx
testl %edx, %edx
je 0xa6b2
orb $0x20, 0x2(%rsi)
movl %r8d, %eax
negl %eax
testl %edi, %edi
cmovnsl %r8d, %eax
retq
cmpl $0xff, %ecx
sete %cl
testl %edx, %edx
setne %dl
testb %cl, %dl
je 0xa66d
jmp 0xa690
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_int16_round_to_zero
int_fast16_t float32_to_int16_round_to_zero(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint32_t aSig;
    int32 z;

    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );
    shiftCount = aExp - 0x8E;
    if ( 0 <= shiftCount ) {
        if ( float32_val(a) != 0xC7000000 ) {
            float_raise(float_flag_invalid, status);
            if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
                return 0x7FFF;
            }
        }
        return (int32_t) 0xffff8000;
    }
    else if ( aExp <= 0x7E ) {
        if ( aExp | aSig ) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    shiftCount -= 0x10;
    aSig = ( aSig | 0x00800000 )<<8;
    z = aSig>>( - shiftCount );
    if ( (uint32_t) ( aSig<<( shiftCount & 31 ) ) ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    if ( aSign ) {
        z = - z;
    }
    return z;

}

// Assembly:
movl %edi, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %edi, %eax
shrl $0x17, %eax
movzbl %al, %ecx
cmpl $0x8e, %ecx
jb 0xa6fa
cmpl $0xc7000000, %edi       # imm = 0xC7000000
jne 0xa70a
movq $-0x8000, %rax          # imm = 0x8000
retq
cmpl $0x7e, %ecx
ja 0xa718
orl %edx, %ecx
je 0xa707
orb $0x20, 0x2(%rsi)
xorl %eax, %eax
retq
orb $0x1, 0x2(%rsi)
movl $0x7fff, %eax           # imm = 0x7FFF
testl %edi, %edi
js 0xa747
retq
shll $0x8, %edx
orl $0x80000000, %edx       # imm = 0x80000000
movb $-0x62, %cl
subb %al, %cl
movl %edx, %r8d
shrl %cl, %r8d
addb $0x2, %al
movl %eax, %ecx
shll %cl, %edx
testl %edx, %edx
je 0xa739
orb $0x20, 0x2(%rsi)
movl %r8d, %eax
negl %eax
testl %edi, %edi
cmovnsl %r8d, %eax
cltq
retq
cmpl $0xff, %ecx
sete %cl
testl %edx, %edx
setne %dl
testb %cl, %dl
je 0xa6f2
jmp 0xa717
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_int64
int64 float32_to_int64(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint32_t aSig;
    uint64_t aSig64, aSigExtra;
    a = float32_squash_input_denormal(a, status);

    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );
    shiftCount = 0xBE - aExp;
    if ( shiftCount < 0 ) {
        float_raise(float_flag_invalid, status);
        if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
            return LIT64( 0x7FFFFFFFFFFFFFFF );
        }
        return (int64_t) LIT64( 0x8000000000000000 );
    }
    if ( aExp ) aSig |= 0x00800000;
    aSig64 = aSig;
    aSig64 <<= 40;
    shift64ExtraRightJamming( aSig64, 0, shiftCount, &aSig64, &aSigExtra );
    return roundAndPackInt64(aSign, aSig64, aSigExtra, status);

}

// Assembly:
movq %rsi, %r8
cmpb $0x0, 0x5(%rsi)
je 0xa785
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xa785
orb $0x40, 0x2(%r8)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %edi, %eax
shrl $0x17, %eax
movzbl %al, %ecx
cmpl $0xbf, %ecx
jb 0xa7b1
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%r8)
testl %edi, %edi
js 0xa7f4
retq
shrl $0x1f, %edi
leal 0x800000(%rdx), %eax
testq %rcx, %rcx
cmovel %edx, %eax
movq %rax, %rsi
shlq $0x28, %rsi
cmpq $0xbe, %rcx
jne 0xa7d4
xorl %edx, %edx
jmp 0xa81c
cmpl $0x7f, %ecx
jb 0xa809
movl $0xbe, %eax
subq %rcx, %rax
addl $0x2, %ecx
andl $0x3f, %ecx
movq %rsi, %rdx
shlq %cl, %rdx
movl %eax, %ecx
shrq %cl, %rsi
jmp 0xa81c
leaq 0x1(%rax), %rsi
cmpl $0xff, %ecx
cmovneq %rsi, %rax
testl %edx, %edx
cmoveq %rsi, %rax
retq
cmpl $0x7e, %ecx
jne 0xa813
movq %rsi, %rdx
jmp 0xa81a
xorl %edx, %edx
testl %eax, %eax
setne %dl
xorl %esi, %esi
movzbl %dil, %edi
movq %r8, %rcx
jmp 0xa825
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: roundAndPackInt64
static int64 roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1,
                               float_status *status)
{
    int8 roundingMode;
    flag roundNearestEven, increment;
    int64_t z;

    roundingMode = status->float_rounding_mode;
    roundNearestEven = ( roundingMode == float_round_nearest_even );
    switch (roundingMode) {
    case float_round_nearest_even:
    case float_round_ties_away:
        increment = ((int64_t) absZ1 < 0);
        break;
    case float_round_to_zero:
        increment = 0;
        break;
    case float_round_up:
        increment = !zSign && absZ1;
        break;
    case float_round_down:
        increment = zSign && absZ1;
        break;
    default:
        abort();
    }
    if ( increment ) {
        ++absZ0;
        if ( absZ0 == 0 ) goto overflow;
        absZ0 &= ~ ( ( (uint64_t) ( absZ1<<1 ) == 0 ) & roundNearestEven );
    }
    z = absZ0;
    if ( zSign ) z = - z;
    if ( z && ( ( z < 0 ) ^ zSign ) ) {
 overflow:
        float_raise(float_flag_invalid, status);
        return
              zSign ? (int64_t) LIT64( 0x8000000000000000 )
            : LIT64( 0x7FFFFFFFFFFFFFFF );
    }
    if (absZ1) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;

}

// Assembly:
movzbl 0x1(%rcx), %eax
cmpq $0x4, %rax
ja 0xa8d8
leaq 0xbf82(%rip), %r8       # 0x167bc
movslq (%r8,%rax,4), %r9
addq %r8, %r9
jmpq *%r9
movq %rdx, %r8
shrq $0x3f, %r8
jmp 0xa867
testb %dil, %dil
sete %r9b
jmp 0xa85d
testb %dil, %dil
setne %r9b
testq %rdx, %rdx
setne %r8b
andb %r9b, %r8b
testb %r8b, %r8b
je 0xa892
incq %rsi
je 0xa8be
testb %al, %al
sete %al
leaq (,%rdx,2), %r8
testq %r8, %r8
sete %r8b
andb %al, %r8b
movzbl %r8b, %eax
notq %rax
andq %rax, %rsi
movq %rsi, %rax
negq %rax
testb %dil, %dil
cmoveq %rsi, %rax
testq %rax, %rax
je 0xa8b4
movq %rax, %rsi
shrq $0x3f, %rsi
movzbl %dil, %r8d
cmpl %r8d, %esi
jne 0xa8be
testq %rdx, %rdx
je 0xa8bd
orb $0x20, 0x2(%rcx)
retq
orb $0x1, 0x2(%rcx)
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%rcx), %rax
testb %dil, %dil
cmoveq %rcx, %rax
retq
pushq %rax
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_uint64
uint64 float32_to_uint64(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint32_t aSig;
    uint64_t aSig64, aSigExtra;
    a = float32_squash_input_denormal(a, status);

    aSig = extractFloat32Frac(a);
    aExp = extractFloat32Exp(a);
    aSign = extractFloat32Sign(a);
    if ((aSign) && (aExp > 126)) {
        float_raise(float_flag_invalid, status);
        if (float32_is_any_nan(a)) {
            return LIT64(0xFFFFFFFFFFFFFFFF);
        } else {
            return 0;
        }
    }
    shiftCount = 0xBE - aExp;
    if (aExp) {
        aSig |= 0x00800000;
    }
    if (shiftCount < 0) {
        float_raise(float_flag_invalid, status);
        return LIT64(0xFFFFFFFFFFFFFFFF);
    }

    aSig64 = aSig;
    aSig64 <<= 40;
    shift64ExtraRightJamming(aSig64, 0, shiftCount, &aSig64, &aSigExtra);
    return roundAndPackUint64(aSign, aSig64, aSigExtra, status);
}

// Assembly:
movq %rsi, %rax
cmpb $0x0, 0x5(%rsi)
je 0xa907
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %dl
orb %cl, %dl
jne 0xa907
orb $0x40, 0x2(%rax)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %ecx
shrl $0x17, %ecx
movzbl %cl, %ecx
testl %edi, %edi
setns %dl
cmpl $0x7f, %ecx
setb %sil
orb %dl, %sil
jne 0xa937
orb $0x1, 0x2(%rax)
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpl $0x7f800001, %edi       # imm = 0x7F800001
adcq $-0x1, %rax
retq
cmpl $0xbf, %ecx
jb 0xa94b
orb $0x1, 0x2(%rax)
movq $-0x1, %rax
retq
movl %edi, %r8d
shrl $0x1f, %r8d
andl $0x7fffff, %edi         # imm = 0x7FFFFF
leal 0x800000(%rdi), %r9d
testl %ecx, %ecx
cmovel %edi, %r9d
movq %r9, %rsi
shlq $0x28, %rsi
cmpl $0xbe, %ecx
jne 0xa978
xorl %edx, %edx
jmp 0xa9ae
cmpl $0x7f, %ecx
jb 0xa99a
movl %ecx, %ecx
movl $0xbe, %edi
subq %rcx, %rdi
addl $0x2, %ecx
andl $0x3f, %ecx
movq %rsi, %rdx
shlq %cl, %rdx
movl %edi, %ecx
shrq %cl, %rsi
jmp 0xa9ae
cmpl $0x7e, %ecx
jne 0xa9a4
movq %rsi, %rdx
jmp 0xa9ac
xorl %edx, %edx
testl %r9d, %r9d
setne %dl
xorl %esi, %esi
movzbl %r8b, %edi
movq %rax, %rcx
jmp 0xa9b7
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: roundAndPackUint64
static int64 roundAndPackUint64(flag zSign, uint64_t absZ0,
                                uint64_t absZ1, float_status *status)
{
    int8 roundingMode;
    flag roundNearestEven, increment;

    roundingMode = status->float_rounding_mode;
    roundNearestEven = (roundingMode == float_round_nearest_even);
    switch (roundingMode) {
    case float_round_nearest_even:
    case float_round_ties_away:
        increment = ((int64_t)absZ1 < 0);
        break;
    case float_round_to_zero:
        increment = 0;
        break;
    case float_round_up:
        increment = !zSign && absZ1;
        break;
    case float_round_down:
        increment = zSign && absZ1;
        break;
    default:
        abort();
    }
    if (increment) {
        ++absZ0;
        if (absZ0 == 0) {
            float_raise(float_flag_invalid, status);
            return LIT64(0xFFFFFFFFFFFFFFFF);
        }
        absZ0 &= ~(((uint64_t)(absZ1<<1) == 0) & roundNearestEven);
    }

    if (zSign && absZ0) {
        float_raise(float_flag_invalid, status);
        return 0;
    }

    if (absZ1) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return absZ0;
}

// Assembly:
movzbl 0x1(%rcx), %eax
cmpq $0x4, %rax
ja 0xaa4b
leaq 0xbe04(%rip), %r8       # 0x167d0
movslq (%r8,%rax,4), %r9
addq %r8, %r9
jmpq *%r9
movq %rdx, %r8
shrq $0x3f, %r8
jmp 0xa9f9
testb %dil, %dil
sete %r9b
jmp 0xa9ef
testb %dil, %dil
setne %r9b
testq %rdx, %rdx
setne %r8b
andb %r9b, %r8b
testb %r8b, %r8b
je 0xaa2d
incq %rsi
jne 0xaa0c
movq $-0x1, %rsi
jmp 0xaa39
testb %al, %al
sete %al
leaq (,%rdx,2), %r8
testq %r8, %r8
sete %r8b
andb %al, %r8b
movzbl %r8b, %eax
notq %rax
andq %rax, %rsi
testb %dil, %dil
je 0xaa3d
testq %rsi, %rsi
je 0xaa3d
xorl %esi, %esi
movb $0x1, %al
jmp 0xaa44
movb $0x20, %al
testq %rdx, %rdx
je 0xaa47
orb %al, 0x2(%rcx)
movq %rsi, %rax
retq
pushq %rax
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_uint64_round_to_zero
uint64 float32_to_uint64_round_to_zero(float32 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 = float32_to_uint64(a, status);
    set_float_rounding_mode(current_rounding_mode, status);
    return v;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x1(%rsi), %bpl
movb $0x3, 0x1(%rsi)
callq 0xa8de
movb %bpl, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_int64_round_to_zero
int64 float32_to_int64_round_to_zero(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint32_t aSig;
    uint64_t aSig64;
    int64 z;
    a = float32_squash_input_denormal(a, status);

    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );
    shiftCount = aExp - 0xBE;
    if ( 0 <= shiftCount ) {
        if ( float32_val(a) != 0xDF000000 ) {
            float_raise(float_flag_invalid, status);
            if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
                return LIT64( 0x7FFFFFFFFFFFFFFF );
            }
        }
        return (int64_t) LIT64( 0x8000000000000000 );
    }
    else if ( aExp <= 0x7E ) {
        if (aExp | aSig) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    aSig64 = aSig | 0x00800000;
    aSig64 <<= 40;
    z = aSig64>>( - shiftCount );
    if ( (uint64_t) ( aSig64<<( shiftCount & 63 ) ) ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    if ( aSign ) z = - z;
    return z;

}

// Assembly:
cmpb $0x0, 0x5(%rsi)
je 0xaa95
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xaa95
orb $0x40, 0x2(%rsi)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %edi, %eax
shrl $0x17, %eax
movzbl %al, %r8d
cmpl $0xbe, %r8d
jb 0xaac5
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpl $0xdf000000, %edi       # imm = 0xDF000000
jne 0xaad7
incq %rax
retq
cmpl $0x7e, %r8d
ja 0xaae0
orl %r8d, %edx
je 0xaad4
orb $0x20, 0x2(%rsi)
xorl %eax, %eax
retq
orb $0x1, 0x2(%rsi)
testl %edi, %edi
js 0xab14
retq
leaq 0x2(%r8), %rax
orl $0x800000, %edx         # imm = 0x800000
shlq $0x28, %rdx
movb $-0x42, %cl
subb %r8b, %cl
movq %rdx, %r8
shrq %cl, %r8
movl %eax, %ecx
shlq %cl, %rdx
testq %rdx, %rdx
je 0xab07
orb $0x20, 0x2(%rsi)
movq %r8, %rax
negq %rax
testl %edi, %edi
cmovnsq %r8, %rax
retq
cmpl $0xff, %r8d
sete %cl
testl %edx, %edx
setne %dl
testb %cl, %dl
je 0xaac1
jmp 0xaadf
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_float64
float64 float32_to_float64(float32 a, 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) {
            return commonNaNToFloat64(float32ToCommonNaN(a, status), status);
        }
        return packFloat64( aSign, 0x7FF, 0 );
    }
    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
        normalizeFloat32Subnormal( aSig, &aExp, &aSig );
        --aExp;
    }
    return packFloat64( aSign, aExp + 0x380, ( (uint64_t) aSig )<<29 );

}

// Assembly:
cmpb $0x0, 0x5(%rsi)
je 0xab4f
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xab4f
orb $0x40, 0x2(%rsi)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %edi, %ecx
shrl $0x17, %ecx
movl %edi, %eax
shrl $0x1f, %eax
testb %cl, %cl
je 0xabd5
movzbl %cl, %ecx
cmpl $0xff, %ecx
jne 0xabee
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testl %edx, %edx
je 0xac10
movl %edi, %edx
andl $0x7fc00000, %edx       # imm = 0x7FC00000
cmpl $0x7f800000, %edx       # imm = 0x7F800000
setne %dl
testl $0x3fffff, %edi         # imm = 0x3FFFFF
sete %r8b
orb %dl, %r8b
jne 0xaba6
orb $0x1, 0x2(%rsi)
shlq $0x29, %rdi
movq %rdi, %rdx
shrq $0xc, %rdx
shlq $0x3f, %rax
orq %rdx, %rax
orq %rcx, %rax
cmpb $0x0, 0x6(%rsi)
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
cmovneq %rcx, %rax
testq %rdi, %rdi
cmoveq %rcx, %rax
retq
testl %edx, %edx
je 0xac18
bsrl %edx, %esi
xorl $0x1f, %esi
leal -0x8(%rsi), %ecx
shll %cl, %edx
movl $0x8, %ecx
subl %esi, %ecx
movslq %ecx, %rcx
movl %edx, %edx
shlq $0x1d, %rdx
shlq $0x3f, %rax
shlq $0x34, %rcx
addq %rax, %rcx
movabsq $0x3800000000000000, %rax # imm = 0x3800000000000000
addq %rdx, %rax
addq %rcx, %rax
retq
shlq $0x3f, %rax
orq %rcx, %rax
retq
shlq $0x3f, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_floatx80
floatx80 float32_to_floatx80(float32 a, 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) {
            return commonNaNToFloatx80(float32ToCommonNaN(a, status), status);
        }
        return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
    }
    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
        normalizeFloat32Subnormal( aSig, &aExp, &aSig );
    }
    aSig |= 0x00800000;
    return packFloatx80( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<40 );

}

// Assembly:
cmpb $0x0, 0x5(%rsi)
je 0xac43
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xac43
orb $0x40, 0x2(%rsi)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
movl %edi, %ecx
shrl $0x17, %ecx
movl %edi, %r8d
shrl $0x1f, %r8d
testb %cl, %cl
je 0xacd5
movzbl %cl, %ecx
cmpl $0xff, %ecx
jne 0xaceb
testl %eax, %eax
je 0xad03
movl %edi, %eax
andl $0x7fc00000, %eax       # imm = 0x7FC00000
cmpl $0x7f800000, %eax       # imm = 0x7F800000
setne %al
testl $0x3fffff, %edi         # imm = 0x3FFFFF
sete %cl
orb %al, %cl
jne 0xac91
orb $0x1, 0x2(%rsi)
movl %edi, %ecx
cmpb $0x0, 0x6(%rsi)
setne %al
testl $0x7fffff, %ecx         # imm = 0x7FFFFF
sete %dl
orb %al, %dl
orq $-0x800000, %rcx        # imm = 0xFF800000
shlq $0x28, %rcx
shll $0xf, %r8d
orl $0x7fff, %r8d           # imm = 0x7FFF
testb %dl, %dl
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
cmoveq %rcx, %rax
movl $0xffff, %edx           # imm = 0xFFFF
cmovel %r8d, %edx
retq
testl %eax, %eax
je 0xad1a
bsrl %eax, %edx
xorl $0x1f, %edx
leal -0x8(%rdx), %ecx
shll %cl, %eax
movl $0x9, %ecx
subl %edx, %ecx
orl $0x800000, %eax         # imm = 0x800000
shlq $0x28, %rax
shll $0xf, %r8d
leal (%rcx,%r8), %edx
addl $0x3f80, %edx           # imm = 0x3F80
retq
shll $0xf, %r8d
orl $0x7fff, %r8d           # imm = 0x7FFF
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
jmp 0xad20
shll $0xf, %r8d
xorl %eax, %eax
movl %r8d, %edx
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_to_float128
float128 float32_to_float128(float32 a, 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) {
            return commonNaNToFloat128(float32ToCommonNaN(a, status), status);
        }
        return packFloat128( aSign, 0x7FFF, 0, 0 );
    }
    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
        normalizeFloat32Subnormal( aSig, &aExp, &aSig );
        --aExp;
    }
    return packFloat128( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<25, 0 );

}

// Assembly:
cmpb $0x0, 0x5(%rsi)
je 0xad4a
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xad4a
orb $0x40, 0x2(%rsi)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %r8d
andl $0x7fffff, %r8d         # imm = 0x7FFFFF
movl %edi, %ecx
shrl $0x17, %ecx
movl %edi, %eax
shrl $0x1f, %eax
testb %cl, %cl
je 0xadc4
movzbl %cl, %edx
cmpl $0xff, %edx
jne 0xaddd
movabsq $0x7fff000000000000, %rcx # imm = 0x7FFF000000000000
testl %r8d, %r8d
je 0xadfa
movl %edi, %edx
andl $0x7fc00000, %edx       # imm = 0x7FC00000
cmpl $0x7f800000, %edx       # imm = 0x7F800000
setne %dl
testl $0x3fffff, %edi         # imm = 0x3FFFFF
sete %r8b
orb %dl, %r8b
jne 0xada0
orb $0x1, 0x2(%rsi)
movl %edi, %edx
shlq $0x19, %rdx
shlq $0x3f, %rax
orq %rdx, %rax
orq %rcx, %rax
cmpb $0x0, 0x6(%rsi)
movabsq $0x7fff800000000000, %rdx # imm = 0x7FFF800000000000
cmoveq %rax, %rdx
jmp 0xae0a
testl %r8d, %r8d
je 0xae03
bsrl %r8d, %esi
xorl $0x1f, %esi
leal -0x8(%rsi), %ecx
shll %cl, %r8d
movl $0x8, %edx
subl %esi, %edx
addl $0x3f80, %edx           # imm = 0x3F80
movl %r8d, %ecx
shlq $0x19, %rcx
shlq $0x3f, %rax
orq %rcx, %rax
shlq $0x30, %rdx
addq %rax, %rdx
jmp 0xae0a
shlq $0x3f, %rax
orq %rcx, %rax
jmp 0xae07
shlq $0x3f, %rax
movq %rax, %rdx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: propagateFloat32NaN
static float32 propagateFloat32NaN(float32 a, float32 b, float_status *status)
{
    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    flag aIsLargerSignificand;
    uint32_t av, bv;

    aIsQuietNaN = float32_is_quiet_nan( a );
    aIsSignalingNaN = float32_is_signaling_nan( a );
    bIsQuietNaN = float32_is_quiet_nan( b );
    bIsSignalingNaN = float32_is_signaling_nan( b );
    av = float32_val(a);
    bv = float32_val(b);

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

    if (status->default_nan_mode)
        return float32_default_nan;

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

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

// Assembly:
movl $0x7fc00000, %eax       # imm = 0x7FC00000
movl %edi, %ecx
andl %eax, %ecx
movl $0x7f800000, %r9d       # imm = 0x7F800000
cmpl %r9d, %ecx
sete %r8b
testl $0x3fffff, %edi         # imm = 0x3FFFFF
setne %r10b
andb %r8b, %r10b
movl %esi, %r8d
andl %eax, %r8d
cmpl %r9d, %r8d
sete %r11b
testl $0x3fffff, %esi         # imm = 0x3FFFFF
setne %r9b
andb %r11b, %r9b
movl %r10d, %r11d
orb %r9b, %r11b
cmpb $0x1, %r11b
jne 0xafb1
orb $0x1, 0x2(%rdx)
cmpb $0x0, 0x6(%rdx)
je 0xafb8
retq
leal (%rdi,%rdi), %r11d
leal (%rsi,%rsi), %edx
cmpl %edx, %r11d
jae 0xafc8
xorl %eax, %eax
jmp 0xafd1
movb $0x1, %al
ja 0xafd1
cmpl %esi, %edi
setb %al
testb %r10b, %r10b
je 0xb011
xorl %r10d, %r10d
cmpl $0xff800000, %edx       # imm = 0xFF800000
setae %r10b
xorl %edx, %edx
testb %al, %al
sete %dl
testb %r9b, %r9b
cmovnel %edx, %r10d
cmpb $0x1, %r10b
je 0xb027
movl %edi, %eax
orl $0x400000, %eax         # imm = 0x400000
testl $0x3fffff, %edi         # imm = 0x3FFFFF
cmovel %edi, %eax
cmpl $0x7f800000, %ecx       # imm = 0x7F800000
cmovnel %edi, %eax
retq
cmpl $0xff800000, %r11d      # imm = 0xFF800000
jb 0xb027
cmpl $0xff800000, %edx       # imm = 0xFF800000
jb 0xaff7
orb %r9b, %al
jne 0xaff7
movl %esi, %eax
orl $0x400000, %eax         # imm = 0x400000
testl $0x3fffff, %esi         # imm = 0x3FFFFF
cmovel %esi, %eax
cmpl $0x7f800000, %r8d       # imm = 0x7F800000
cmovnel %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_add
float32 float32_add(float32 a, float32 b, float_status *status)
{
    flag aSign, bSign;
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    aSign = extractFloat32Sign( a );
    bSign = extractFloat32Sign( b );
    if ( aSign == bSign ) {
        return addFloat32Sigs(a, b, aSign, status);
    }
    else {
        return subFloat32Sigs(a, b, aSign, status);
    }

}

// Assembly:
movq %rdx, %rcx
cmpb $0x0, 0x5(%rdx)
je 0xb08b
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %dl
orb %al, %dl
jne 0xb06b
orb $0x40, 0x2(%rcx)
andl $0x80000000, %edi       # imm = 0x80000000
testl $0x7f800000, %esi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %dl
orb %al, %dl
jne 0xb08b
orb $0x40, 0x2(%rcx)
andl $0x80000000, %esi       # imm = 0x80000000
movl %edi, %eax
shrl $0x1f, %eax
movl %esi, %edx
shrl $0x1f, %edx
cmpl %edx, %eax
jne 0xb09e
movzbl %al, %edx
jmp 0xb0a6
movzbl %al, %edx
jmp 0xb231
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: estimateDiv128To64
static uint64_t estimateDiv128To64( uint64_t a0, uint64_t a1, uint64_t b )
{
    uint64_t b0, b1;
    uint64_t rem0, rem1, term0, term1;
    uint64_t z;

    if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF );
    b0 = b>>32;
    z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32;
    mul64To128( b, z, &term0, &term1 );
    sub128( a0, a1, term0, term1, &rem0, &rem1 );
    while ( ( (int64_t) rem0 ) < 0 ) {
        z -= LIT64( 0x100000000 );
        b1 = b<<32;
        add128( rem0, rem1, b0, b1, &rem0, &rem1 );
    }
    rem0 = ( rem0<<32 ) | ( rem1>>32 );
    z |= ( b0<<32 <= rem0 ) ? 0xFFFFFFFF : rem0 / b0;
    return z;

}

// Assembly:
movq $-0x1, %rax
cmpq %rdi, %rdx
jbe 0xbb01
movq %rdx, %r8
movabsq $-0x100000000, %r11     # imm = 0xFFFFFFFF00000000
movq %rdx, %r9
shrq $0x20, %r9
movq %rdx, %r10
andq %r11, %r10
movq %r11, %rcx
cmpq %rdi, %r10
jbe 0xba6c
movq %rdi, %rax
xorl %edx, %edx
divq %r9
movq %rax, %rcx
shlq $0x20, %rcx
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rax
shrq $0x20, %rax
movl %r8d, %edx
imulq %rax, %rdx
imulq %r9, %rax
movq %rdx, %r14
shrq $0x20, %r14
addq %rax, %r14
shlq $0x20, %rdx
movq %rcx, %r15
imulq %r8, %r15
movq %rsi, %rbx
subq %r15, %rbx
sbbq %r14, %rdi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %r15
sbbq $0x0, %rdi
js 0xbab4
movq %rbx, %rdx
jmp 0xbae7
movq %r8, %r14
shlq $0x20, %r14
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
subq %rcx, %rdx
incq %rdx
imulq %r8, %rdx
addq %rdx, %rsi
addq %r11, %rcx
leaq (%rbx,%r14), %rdx
addq %r9, %rdi
cmpq %rbx, %rsi
leaq (%rsi,%r14), %rsi
adcq $0x0, %rdi
movq %rdx, %rbx
js 0xbacd
shrdq $0x20, %rdi, %rdx
cmpq %rdx, %r10
popq %rbx
popq %r14
popq %r15
jbe 0xbafe
movq %rdx, %rax
xorl %edx, %edx
divq %r9
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: estimateSqrt32
static uint32_t estimateSqrt32(int_fast16_t aExp, uint32_t a)
{
    static const uint16_t sqrtOddAdjustments[] = {
        0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
        0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
    };
    static const uint16_t sqrtEvenAdjustments[] = {
        0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
        0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
    };
    int8 index;
    uint32_t z;

    index = ( a>>27 ) & 15;
    if ( aExp & 1 ) {
        z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ (int)index ];
        z = ( ( a / z )<<14 ) + ( z<<15 );
        a >>= 1;
    }
    else {
        z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ (int)index ];
        z = a / z + z;
        z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );
        if ( z <= a ) return (uint32_t) ( ( (int32_t) a )>>1 );
    }
    return ( (uint32_t) ( ( ( (uint64_t) a )<<31 ) / z ) ) + ( z>>1 );

}

// Assembly:
movl %esi, %eax
shrl $0x1b, %eax
testb $0x1, %dil
jne 0xc2c3
movl %esi, %ecx
shrl $0x11, %ecx
orl $0x8000, %ecx           # imm = 0x8000
andl $0xf, %eax
leaq 0xa747(%rip), %rdx      # 0x169e0
movzwl (%rdx,%rax,2), %eax
subl %eax, %ecx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
addl %ecx, %eax
movl %eax, %edx
shll $0xf, %edx
cmpl $0x20000, %eax          # imm = 0x20000
movl $0xffff8000, %ecx       # imm = 0xFFFF8000
cmovbl %edx, %ecx
cmpl %esi, %ecx
ja 0xc2ee
sarl %esi
movl %esi, %ecx
jmp 0xc2ff
andl $0xf, %eax
movl %esi, %ecx
shrl $0x11, %ecx
leaq 0xa6ee(%rip), %rdx      # 0x169c0
movzwl (%rdx,%rax,2), %eax
subl %eax, %ecx
addl $0x4000, %ecx           # imm = 0x4000
movl %esi, %eax
xorl %edx, %edx
divl %ecx
shll $0xe, %eax
shll $0xf, %ecx
addl %eax, %ecx
shrl %esi
movl %esi, %eax
shlq $0x1f, %rax
movl %ecx, %esi
xorl %edx, %edx
divq %rsi
shrl %ecx
addl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_exp2
float32 float32_exp2(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;
    float64 r, x, xn;
    int i;
    a = float32_squash_input_denormal(a, status);

    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );

    if ( aExp == 0xFF) {
        if (aSig) {
            return propagateFloat32NaN(a, float32_zero, status);
        }
        return (aSign) ? float32_zero : a;
    }
    if (aExp == 0) {
        if (aSig == 0) return float32_one;
    }

    float_raise(float_flag_inexact, status);

    /* ******************************* */
    /* using float64 for approximation */
    /* ******************************* */
    x = float32_to_float64(a, status);
    x = float64_mul(x, float64_ln2, status);

    xn = x;
    r = float64_one;
    for (i = 0 ; i < 15 ; i++) {
        float64 f;

        f = float64_mul(xn, float32_exp2_coefficients[i], status);
        r = float64_add(r, f, status);

        xn = float64_mul(xn, x, status);
    }

    return float64_to_float32(r, status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, 0x5(%rsi)
je 0xc336
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xc336
orb $0x40, 0x2(%rbx)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
movl %edi, %ecx
shrl $0x17, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
jne 0xc36d
testl %eax, %eax
je 0xc405
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaf64
orl %eax, %ecx
je 0xc40e
orb $0x20, 0x2(%rbx)
movq %rbx, %rsi
callq 0xab29
movabsq $0x3fe62e42fefa39ef, %rsi # imm = 0x3FE62E42FEFA39EF
movq %rax, %rdi
movq %rbx, %rdx
callq 0xc422
movq %rax, %r14
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
xorl %r13d, %r13d
leaq 0xa593(%rip), %rbp      # 0x16940
movq %rax, %r12
movq (%r13,%rbp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0xc422
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xc61a
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc422
movq %rax, %r12
addq $0x8, %r13
cmpq $0x78, %r13
jne 0xc3b0
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc69b
xorl %eax, %eax
testl %edi, %edi
cmovgl %edi, %eax
jmp 0xc413
movl $0x3f800000, %eax       # imm = 0x3F800000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_add
float64 float64_add(float64 a, float64 b, float_status *status)
{
    flag aSign, bSign;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    aSign = extractFloat64Sign( a );
    bSign = extractFloat64Sign( b );
    if ( aSign == bSign ) {
        return addFloat64Sigs(a, b, aSign, status);
    }
    else {
        return subFloat64Sigs(a, b, aSign, status);
    }

}

// Assembly:
movq %rdx, %rcx
cmpb $0x0, 0x5(%rdx)
je 0xc678
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movabsq $0x7ff0000000000000, %r8 # imm = 0x7FF0000000000000
movabsq $0xfffffffffffff, %rdx  # imm = 0xFFFFFFFFFFFFF
testq %r8, %rdi
setne %r9b
movq %rdi, %r10
shlq $0xc, %r10
sete %r10b
orb %r9b, %r10b
jne 0xc65f
orb $0x40, 0x2(%rcx)
andq %rax, %rdi
testq %r8, %rsi
setne %r8b
testq %rdx, %rsi
sete %dl
orb %r8b, %dl
jne 0xc678
orb $0x40, 0x2(%rcx)
andq %rax, %rsi
movq %rdi, %rax
shrq $0x3f, %rax
movq %rsi, %rdx
shrq $0x3f, %rdx
cmpq %rdx, %rax
jne 0xc693
movzbl %al, %edx
jmp 0xdcf6
movzbl %al, %edx
jmp 0xde9a
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_float32
float32 float64_to_float32(float64 a, 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) {
            return commonNaNToFloat32(float64ToCommonNaN(a, status), status);
        }
        return packFloat32( aSign, 0xFF, 0 );
    }
    shift64RightJamming( aSig, 22, &aSig );
    zSig = aSig;
    if ( aExp || zSig ) {
        zSig |= 0x40000000;
        aExp -= 0x381;
    }
    return roundAndPackFloat32(aSign, aExp, zSig, status);

}

// Assembly:
movq %rsi, %rcx
movabsq $0xfffffffffffff, %rdx  # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rsi)
je 0xc6db
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
testq %rax, %rdi
setne %al
testq %rdx, %rdi
sete %sil
orb %al, %sil
jne 0xc6db
orb $0x40, 0x2(%rcx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %rdi
andq %rdi, %rdx
movq %rdi, %rsi
shrq $0x34, %rsi
movl $0x7ff, %r8d            # imm = 0x7FF
andq %r8, %rsi
movq %rdi, %rax
shrq $0x3f, %rax
cmpq %r8, %rsi
jne 0xc75b
testq %rdx, %rdx
je 0xc795
movabsq $0x7ff8000000000000, %rdx # imm = 0x7FF8000000000000
andq %rdi, %rdx
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
cmpq %rsi, %rdx
setne %dl
movq %rdi, %rsi
shlq $0xd, %rsi
sete %sil
orb %dl, %sil
jne 0xc734
orb $0x1, 0x2(%rcx)
shrq $0x1d, %rdi
andl $0x7fffff, %edi         # imm = 0x7FFFFF
shll $0x1f, %eax
cmpb $0x0, 0x6(%rcx)
leal 0x7f800000(%rax,%rdi), %eax
movl $0x7fc00000, %ecx       # imm = 0x7FC00000
cmovnel %ecx, %eax
testq %rdi, %rdi
cmovel %ecx, %eax
retq
shrq $0x16, %rdx
xorl %r8d, %r8d
shlq $0x2a, %rdi
setne %r8b
orq %rdx, %r8
leal 0x40000000(%r8), %edx
leaq -0x381(%rsi), %rdi
xorl %r9d, %r9d
orq %rsi, %r8
movl $0x0, %esi
cmovneq %rdi, %rsi
cmovel %r9d, %edx
movl %eax, %edi
jmp 0x9f46
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
retq
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_log2
float32 float32_log2(float32 a, float_status *status)
{
    flag aSign, zSign;
    int_fast16_t aExp;
    uint32_t aSig, zSig, i;

    a = float32_squash_input_denormal(a, status);
    aSig = extractFloat32Frac( a );
    aExp = extractFloat32Exp( a );
    aSign = extractFloat32Sign( a );

    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloat32( 1, 0xFF, 0 );
        normalizeFloat32Subnormal( aSig, &aExp, &aSig );
    }
    if ( aSign ) {
        float_raise(float_flag_invalid, status);
        return float32_default_nan;
    }
    if ( aExp == 0xFF ) {
        if (aSig) {
            return propagateFloat32NaN(a, float32_zero, status);
        }
        return a;
    }

    aExp -= 0x7F;
    aSig |= 0x00800000;
    zSign = aExp < 0;
    zSig = aExp << 23;

    for (i = 1 << 22; i > 0; i >>= 1) {
        aSig = ( (uint64_t)aSig * aSig ) >> 23;
        if ( aSig & 0x01000000 ) {
            aSig >>= 1;
            zSig |= i;
        }
    }

    if ( zSign )
        zSig = -zSig;

    return normalizeRoundAndPackFloat32(zSign, 0x85, zSig, status);
}

// Assembly:
movq %rsi, %rax
cmpb $0x0, 0x5(%rsi)
je 0xc7c7
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %dl
orb %cl, %dl
jne 0xc7c7
orb $0x40, 0x2(%rax)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %esi
andl $0x7fffff, %esi         # imm = 0x7FFFFF
movl %edi, %ecx
shrl $0x17, %ecx
movzbl %cl, %r8d
testl %r8d, %r8d
jne 0xc7fa
testl %esi, %esi
je 0xc87f
bsrl %esi, %edx
xorl $0x1f, %edx
leal -0x8(%rdx), %ecx
shll %cl, %esi
movl $0x9, %ecx
subl %edx, %ecx
movslq %ecx, %r8
testl %edi, %edi
js 0xc815
cmpq $0xff, %r8
jne 0xc820
testl %esi, %esi
je 0xc884
xorl %esi, %esi
movq %rax, %rdx
jmp 0xaf64
orb $0x1, 0x2(%rax)
movl $0x7fc00000, %edi       # imm = 0x7FC00000
jmp 0xc884
orl $0x800000, %esi         # imm = 0x800000
movl %r8d, %edx
shll $0x17, %edx
addl $0xc0800000, %edx       # imm = 0xC0800000
movl $0x400000, %edi         # imm = 0x400000
movl $0x400000, %r9d         # imm = 0x400000
movl %esi, %esi
imulq %rsi, %rsi
shrq $0x17, %rsi
movl %esi, %r10d
shll $0x7, %r10d
sarl $0x1f, %r10d
movl %esi, %ecx
shrl $0x18, %ecx
andl $0x1, %ecx
shrl %cl, %esi
andl %edi, %r10d
orl %r10d, %edx
shrl %r9d
cmpl $0x1, %edi
movl %r9d, %edi
ja 0xc83d
cmpq $0x7f, %r8
jge 0xc887
negl %edx
je 0xc893
bsrl %edx, %ecx
xorl $0x1f, %ecx
jmp 0xc898
movl $0xff800000, %edi       # imm = 0xFF800000
movl %edi, %eax
retq
testl %edx, %edx
je 0xc8af
bsrl %edx, %ecx
xorl $0x1f, %ecx
jmp 0xc8b4
movl $0x20, %ecx
decb %cl
movsbq %cl, %rcx
movl $0x85, %esi
subq %rcx, %rsi
shll %cl, %edx
movl $0x1, %edi
jmp 0xc8c6
movl $0x20, %ecx
decb %cl
movsbq %cl, %rcx
movl $0x85, %esi
subq %rcx, %rsi
shll %cl, %edx
xorl %edi, %edi
movq %rax, %rcx
jmp 0x9f46
// File: /workspace/github_c_makefile_star2_O3/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_le
int float32_le(float32 a, float32 b, float_status *status)
{
    flag aSign, bSign;
    uint32_t av, bv;
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    aSign = extractFloat32Sign( a );
    bSign = extractFloat32Sign( b );
    av = float32_val(a);
    bv = float32_val(b);
    if ( aSign != bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
    return ( av == bv ) || ( aSign ^ ( av < bv ) );

}

// Assembly:
cmpb $0x0, 0x5(%rdx)
je 0xc9a9
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xc989
orb $0x40, 0x2(%rdx)
andl $0x80000000, %edi       # imm = 0x80000000
testl $0x7f800000, %esi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xc9a9
orb $0x40, 0x2(%rdx)
andl $0x80000000, %esi       # imm = 0x80000000
movl %edi, %eax
notl %eax
testl $0x7f800000, %eax       # imm = 0x7F800000
sete %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
setne %cl
testb %cl, %al
jne 0xc9f2
movl %esi, %eax
notl %eax
testl $0x7f800000, %eax       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
je 0xc9f2
movl %esi, %eax
xorl %edi, %eax
js 0xc9fa
cmpl %esi, %edi
sete %cl
setb %dl
testl %edi, %edi
sets %al
xorb %dl, %al
jmp 0xca0a
orb $0x1, 0x2(%rdx)
xorl %eax, %eax
jmp 0xca0c
testl %edi, %edi
sets %cl
orl %edi, %esi
testl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
sete %al
orb %cl, %al
movzbl %al, %eax
retq