LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xa56d
leaq 0xc2d4(%rip), %rcx      # 0x167a8
movslq (%rcx,%rax,4), %r8
addq %rcx, %r8
jmpq *%r8
movl $0x40, %ecx
jmp 0xa509
xorl %ecx, %ecx
jmp 0xa509
xorl %r8d, %r8d
testb %dil, %dil
movl $0x7f, %ecx
cmoveq %r8, %rcx
jmp 0xa509
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 0xa55c
testl %eax, %eax
je 0xa552
movl %eax, %ecx
shrl $0x1f, %ecx
movzbl %dil, %esi
cmpl %esi, %ecx
jne 0xa55c
testb %r8b, %r8b
je 0xa55b
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_O1/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 0xa599
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xa599
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 0xa5bf
cmpl $0xcf000000, %edi       # imm = 0xCF000000
jne 0xa5cf
movl $0x80000000, %eax       # imm = 0x80000000
retq
cmpl $0x7e, %ecx
ja 0xa5dd
xorl %eax, %eax
orl %edx, %ecx
je 0xa5dc
orb $0x20, 0x2(%rsi)
retq
orb $0x1, 0x2(%rsi)
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
testl %edi, %edi
js 0xa60a
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 0xa5fe
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 0xa5b9
jmp 0xa5dc
// File: /workspace/github_c_makefile_star2_O1/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 0xa646
cmpl $0xc7000000, %edi       # imm = 0xC7000000
jne 0xa656
movq $-0x8000, %rax          # imm = 0x8000
retq
cmpl $0x7e, %ecx
ja 0xa664
orl %edx, %ecx
je 0xa653
orb $0x20, 0x2(%rsi)
xorl %eax, %eax
retq
orb $0x1, 0x2(%rsi)
movl $0x7fff, %eax           # imm = 0x7FFF
testl %edi, %edi
js 0xa693
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 0xa685
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 0xa63e
jmp 0xa663
// File: /workspace/github_c_makefile_star2_O1/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 0xa6d1
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xa6d1
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 0xa6fd
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%r8)
testl %edi, %edi
js 0xa740
retq
shrl $0x1f, %edi
leal 0x800000(%rdx), %eax
testq %rcx, %rcx
cmovel %edx, %eax
movq %rax, %rsi
shlq $0x28, %rsi
cmpq $0xbe, %rcx
jne 0xa720
xorl %edx, %edx
jmp 0xa768
cmpl $0x7f, %ecx
jb 0xa755
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 0xa768
leaq 0x1(%rax), %rsi
cmpl $0xff, %ecx
cmovneq %rsi, %rax
testl %edx, %edx
cmoveq %rsi, %rax
retq
cmpl $0x7e, %ecx
jne 0xa75f
movq %rsi, %rdx
jmp 0xa766
xorl %edx, %edx
testl %eax, %eax
setne %dl
xorl %esi, %esi
movzbl %dil, %edi
movq %r8, %rcx
jmp 0xa771
// File: /workspace/github_c_makefile_star2_O1/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 0xa829
leaq 0xc036(%rip), %r8       # 0x167bc
movslq (%r8,%rax,4), %r9
addq %r8, %r9
jmpq *%r9
movq %rdx, %r8
shrq $0x3f, %r8
jmp 0xa7b8
xorl %r8d, %r8d
jmp 0xa7b8
testb %dil, %dil
setne %r9b
jmp 0xa7ae
testb %dil, %dil
sete %r9b
testq %rdx, %rdx
setne %r8b
andb %r9b, %r8b
testb %r8b, %r8b
je 0xa7e3
incq %rsi
je 0xa80f
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 0xa805
movq %rax, %rsi
shrq $0x3f, %rsi
movzbl %dil, %r8d
cmpl %r8d, %esi
jne 0xa80f
testq %rdx, %rdx
je 0xa80e
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_O1/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 0xa858
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %dl
orb %cl, %dl
jne 0xa858
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 0xa888
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 0xa89c
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 0xa8c9
xorl %edx, %edx
jmp 0xa8ff
cmpl $0x7f, %ecx
jb 0xa8eb
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 0xa8ff
cmpl $0x7e, %ecx
jne 0xa8f5
movq %rsi, %rdx
jmp 0xa8fd
xorl %edx, %edx
testl %r9d, %r9d
setne %dl
xorl %esi, %esi
movzbl %r8b, %edi
movq %rax, %rcx
jmp 0xa908
// File: /workspace/github_c_makefile_star2_O1/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 0xa9a1
leaq 0xbeb3(%rip), %r8       # 0x167d0
movslq (%r8,%rax,4), %r9
addq %r8, %r9
jmpq *%r9
movq %rdx, %r8
shrq $0x3f, %r8
jmp 0xa94f
xorl %r8d, %r8d
jmp 0xa94f
testb %dil, %dil
setne %r9b
jmp 0xa945
testb %dil, %dil
sete %r9b
testq %rdx, %rdx
setne %r8b
andb %r9b, %r8b
testb %r8b, %r8b
je 0xa983
incq %rsi
jne 0xa962
movq $-0x1, %rsi
jmp 0xa98f
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 0xa993
testq %rsi, %rsi
je 0xa993
xorl %esi, %esi
movb $0x1, %al
jmp 0xa99a
movb $0x20, %al
testq %rdx, %rdx
je 0xa99d
orb %al, 0x2(%rcx)
movq %rsi, %rax
retq
pushq %rax
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 0xa82f
movb %bpl, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa9eb
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xa9eb
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 0xaa1b
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpl $0xdf000000, %edi       # imm = 0xDF000000
jne 0xaa2d
incq %rax
retq
cmpl $0x7e, %r8d
ja 0xaa36
orl %r8d, %edx
je 0xaa2a
orb $0x20, 0x2(%rsi)
xorl %eax, %eax
retq
orb $0x1, 0x2(%rsi)
testl %edi, %edi
js 0xaa6a
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 0xaa5d
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 0xaa17
jmp 0xaa35
// File: /workspace/github_c_makefile_star2_O1/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 0xaaa5
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xaaa5
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 0xab2b
movzbl %cl, %ecx
cmpl $0xff, %ecx
jne 0xab44
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testl %edx, %edx
je 0xab66
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 0xaafc
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 0xab6e
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_O1/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 0xab99
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xab99
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 0xac2b
movzbl %cl, %ecx
cmpl $0xff, %ecx
jne 0xac41
testl %eax, %eax
je 0xac59
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 0xabe7
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 0xac70
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 0xac76
shll $0xf, %r8d
xorl %eax, %eax
movl %r8d, %edx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaca0
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xaca0
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 0xad1a
movzbl %cl, %edx
cmpl $0xff, %edx
jne 0xad33
movabsq $0x7fff000000000000, %rcx # imm = 0x7FFF000000000000
testl %r8d, %r8d
je 0xad50
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 0xacf6
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 0xad60
testl %r8d, %r8d
je 0xad59
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 0xad60
shlq $0x3f, %rax
orq %rcx, %rax
jmp 0xad5d
shlq $0x3f, %rax
movq %rax, %rdx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaefb
orb $0x1, 0x2(%rdx)
cmpb $0x0, 0x6(%rdx)
je 0xaf02
retq
leal (%rdi,%rdi), %r11d
leal (%rsi,%rsi), %eax
cmpl %eax, %r11d
jae 0xaf12
xorl %edx, %edx
jmp 0xaf1b
movb $0x1, %dl
ja 0xaf1b
cmpl %esi, %edi
setb %dl
testb %r10b, %r10b
je 0xaf3c
xorl %r10d, %r10d
cmpl $0xff800000, %eax       # imm = 0xFF800000
setae %r10b
xorl %eax, %eax
testb %dl, %dl
sete %al
testb %r9b, %r9b
cmovnel %eax, %r10d
jmp 0xaf57
cmpl $0xff800000, %r11d      # imm = 0xFF800000
jb 0xaf5c
cmpl $0xff800000, %eax       # imm = 0xFF800000
setae %al
orb %r9b, %dl
sete %r10b
andb %al, %r10b
testb %r10b, %r10b
je 0xaf77
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
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
// File: /workspace/github_c_makefile_star2_O1/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
movb 0x5(%rdx), %al
testb %al, %al
je 0xafbd
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %dl
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %r8b
orb %dl, %r8b
jne 0xafbd
orb $0x40, 0x2(%rcx)
andl $0x80000000, %edi       # imm = 0x80000000
testb %al, %al
je 0xafe1
testl $0x7f800000, %esi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %dl
orb %al, %dl
jne 0xafe1
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 0xaff4
movzbl %al, %edx
jmp 0xaffc
movzbl %al, %edx
jmp 0xb192
// File: /workspace/github_c_makefile_star2_O1/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 0xba75
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 0xb9e0
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 0xba28
movq %rbx, %rdx
jmp 0xba5b
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 0xba41
shrdq $0x20, %rdi, %rdx
cmpq %rdx, %r10
popq %rbx
popq %r14
popq %r15
jbe 0xba72
movq %rdx, %rax
xorl %edx, %edx
divq %r9
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc1f2
movl %esi, %ecx
shrl $0x11, %ecx
orl $0x8000, %ecx           # imm = 0x8000
andl $0xf, %eax
leaq 0xa818(%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 0xc21d
sarl %esi
movl %esi, %ecx
jmp 0xc22e
andl $0xf, %eax
movl %esi, %ecx
shrl $0x11, %ecx
leaq 0xa7bf(%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_O1/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 0xc265
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xc265
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 0xc29c
testl %eax, %eax
je 0xc334
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaeae
orl %eax, %ecx
je 0xc33d
orb $0x20, 0x2(%rbx)
movq %rbx, %rsi
callq 0xaa7f
movabsq $0x3fe62e42fefa39ef, %rsi # imm = 0x3FE62E42FEFA39EF
movq %rax, %rdi
movq %rbx, %rdx
callq 0xc351
movq %rax, %r14
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
xorl %r13d, %r13d
leaq 0xa664(%rip), %rbp      # 0x16940
movq %rax, %r12
movq (%r13,%rbp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0xc351
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xc547
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc351
movq %rax, %r12
addq $0x8, %r13
cmpq $0x78, %r13
jne 0xc2df
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc5d4
xorl %eax, %eax
testl %edi, %edi
cmovgl %edi, %eax
jmp 0xc342
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_O1/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
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
movb 0x5(%rcx), %r8b
testb %r8b, %r8b
je 0xc58b
testq %rdx, %rdi
setne %r9b
testq %rax, %rdi
sete %r10b
orb %r9b, %r10b
jne 0xc58b
orb $0x40, 0x2(%rcx)
movabsq $-0x8000000000000000, %r9 # imm = 0x8000000000000000
andq %r9, %rdi
testb %r8b, %r8b
je 0xc5b1
testq %rdx, %rsi
setne %dl
testq %rax, %rsi
sete %al
orb %dl, %al
jne 0xc5b1
orb $0x40, 0x2(%rcx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %rsi
movq %rdi, %rax
shrq $0x3f, %rax
movq %rsi, %rdx
shrq $0x3f, %rdx
cmpq %rdx, %rax
jne 0xc5cc
movzbl %al, %edx
jmp 0xdc48
movzbl %al, %edx
jmp 0xddf5
// File: /workspace/github_c_makefile_star2_O1/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 0xc614
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
testq %rax, %rdi
setne %al
testq %rdx, %rdi
sete %sil
orb %al, %sil
jne 0xc614
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 0xc694
testq %rdx, %rdx
je 0xc6ce
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 0xc66d
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 0x9e9b
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc700
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %dl
orb %cl, %dl
jne 0xc700
orb $0x40, 0x2(%rax)
andl $0x80000000, %edi       # imm = 0x80000000
movl %edi, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %edi, %ecx
shrl $0x17, %ecx
movzbl %cl, %esi
testl %esi, %esi
jne 0xc731
testl %edx, %edx
je 0xc7c9
bsrl %edx, %esi
xorl $0x1f, %esi
leal -0x8(%rsi), %ecx
shll %cl, %edx
movl $0x9, %ecx
subl %esi, %ecx
movslq %ecx, %rsi
testl %edi, %edi
js 0xc750
cmpq $0xff, %rsi
jne 0xc75b
testl %edx, %edx
je 0xc7ce
xorl %esi, %esi
movq %rax, %rdx
jmp 0xaeae
orb $0x1, 0x2(%rax)
movl $0x7fc00000, %edi       # imm = 0x7FC00000
jmp 0xc7ce
orl $0x800000, %edx         # imm = 0x800000
movl %esi, %r8d
shll $0x17, %r8d
addl $0xc0800000, %r8d       # imm = 0xC0800000
movl $0x400000, %edi         # imm = 0x400000
movl $0x400000, %r9d         # imm = 0x400000
movl %edx, %edx
imulq %rdx, %rdx
shrq $0x17, %rdx
movl %edx, %r10d
shll $0x7, %r10d
sarl $0x1f, %r10d
movl %edx, %ecx
shrl $0x18, %ecx
andl $0x1, %ecx
shrl %cl, %edx
andl %edi, %r10d
orl %r10d, %r8d
shrl %r9d
cmpl $0x1, %edi
movl %r9d, %edi
ja 0xc77a
movl %r8d, %edx
negl %edx
xorl %edi, %edi
cmpq $0x7f, %rsi
setl %r9b
cmovgel %r8d, %edx
testl %edx, %edx
je 0xc7d1
bsrl %edx, %ecx
xorl $0x1f, %ecx
jmp 0xc7d6
movl $0xff800000, %edi       # imm = 0xFF800000
movl %edi, %eax
retq
movl $0x20, %ecx
decb %cl
movsbq %cl, %rcx
movl $0x85, %esi
subq %rcx, %rsi
shll %cl, %edx
movb %r9b, %dil
movq %rax, %rcx
jmp 0x9e9b
// File: /workspace/github_c_makefile_star2_O1/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:
movb 0x5(%rdx), %al
testb %al, %al
je 0xc8b6
testl $0x7f800000, %edi       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %edi         # imm = 0x7FFFFF
sete %r8b
orb %cl, %r8b
jne 0xc8b6
orb $0x40, 0x2(%rdx)
andl $0x80000000, %edi       # imm = 0x80000000
testb %al, %al
je 0xc8da
testl $0x7f800000, %esi       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
jne 0xc8da
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 0xc923
movl %esi, %eax
notl %eax
testl $0x7f800000, %eax       # imm = 0x7F800000
setne %al
testl $0x7fffff, %esi         # imm = 0x7FFFFF
sete %cl
orb %al, %cl
je 0xc923
movl %esi, %eax
xorl %edi, %eax
js 0xc92b
cmpl %esi, %edi
sete %cl
setb %dl
testl %edi, %edi
sets %al
xorb %dl, %al
jmp 0xc93b
orb $0x1, 0x2(%rdx)
xorl %eax, %eax
jmp 0xc93d
testl %edi, %edi
sets %cl
orl %edi, %esi
testl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
sete %al
orb %cl, %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int32
int32 float64_to_int32(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
    if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
    shiftCount = 0x42C - aExp;
    if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );
    return roundAndPackInt32(aSign, aSig, status);

}

// Assembly:
movq %rsi, %rdx
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rsi)
je 0xce2d
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
testq %rax, %rdi
setne %al
testq %rcx, %rdi
sete %sil
orb %al, %sil
jne 0xce2d
orb $0x40, 0x2(%rdx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %rdi
movq %rdi, %r8
andq %rcx, %r8
movq %rdi, %rax
shrq $0x34, %rax
movl %eax, %r9d
andl $0x7ff, %r9d            # imm = 0x7FF
leaq 0x1(%rcx,%r8), %rsi
cmoveq %r8, %rsi
cmpq $0x42b, %r9             # imm = 0x42B
ja 0xce89
cmpl $0x3ed, %r9d            # imm = 0x3ED
jb 0xce7e
movb $0x2c, %cl
subb %r9b, %cl
movq %rsi, %r10
shrq %cl, %r10
addb $0x14, %al
movl %eax, %ecx
shlq %cl, %rsi
xorl %eax, %eax
testq %rsi, %rsi
setne %al
orq %r10, %rax
jmp 0xce86
xorl %eax, %eax
testq %rsi, %rsi
setne %al
movq %rax, %rsi
shrq $0x3f, %rdi
xorl %eax, %eax
cmpl $0x7ff, %r9d            # imm = 0x7FF
cmovnel %edi, %eax
testq %r8, %r8
cmovel %edi, %eax
movl %eax, %edi
jmp 0xa4bf
// File: /workspace/github_c_makefile_star2_O1/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int32_round_to_zero
int32 float64_to_int32_round_to_zero(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig, savedASig;
    int32_t z;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( 0x41E < 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 ( ( 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:
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
cmpb $0x0, 0x5(%rsi)
je 0xcee1
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testq %rcx, %rdi
setne %cl
testq %rax, %rdi
sete %dl
orb %cl, %dl
jne 0xcee1
orb $0x40, 0x2(%rsi)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rdi
movq %rdi, %rcx
andq %rax, %rcx
movq %rdi, %r8
shrq $0x34, %r8
andl $0x7ff, %r8d            # imm = 0x7FF
movq %rdi, %rdx
shrq $0x3f, %rdx
cmpq $0x41f, %r8             # imm = 0x41F
jb 0xcf2a
movzbl %dl, %eax
xorl %edx, %edx
cmpl $0x7ff, %r8d            # imm = 0x7FF
cmovnel %eax, %edx
testq %rcx, %rcx
cmovel %eax, %edx
orb $0x1, 0x2(%rsi)
cmpb $0x1, %dl
movl $0x80000000, %eax       # imm = 0x80000000
sbbl $0x0, %eax
retq
cmpl $0x3fe, %r8d            # imm = 0x3FE
ja 0xcf3f
xorl %eax, %eax
orq %rcx, %r8
je 0xcf3e
orb $0x20, 0x2(%rsi)
retq
leaq (%rax,%rcx), %r9
incq %r9
movl $0x433, %ecx            # imm = 0x433
subq %r8, %rcx
movq %r9, %r8
shrq %cl, %r8
movl %r8d, %eax
negl %eax
testq %rdi, %rdi
cmovnsl %r8d, %eax
movl %eax, %edi
shrl $0x1f, %edi
cmpl %edx, %edi
jne 0xcf1a
shlq %cl, %r8
cmpq %r9, %r8
jne 0xcf3a
jmp 0xcf3e