LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: le_sf64
int glue(le_sf, F_SIZE)(F_UINT a, F_UINT b, uint32_t *pfflags)
{
    uint32_t a_sign, b_sign;

    if (isnan_sf(a) || isnan_sf(b)) {
        *pfflags |= FFLAG_INVALID_OP;
        return 0;
    }

    a_sign = a >> (F_SIZE - 1);
    b_sign = b >> (F_SIZE - 1);
    if (a_sign != b_sign) {
        return (a_sign || ((F_UINT)((a | b) << 1) == 0));
    } else {
        if (a_sign) {
            return (a >= b);
        } else {
            return (a <= b);
        }
    }
}

// Assembly:
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rdi, %rcx
notq %rcx
testq %rax, %rcx
sete %cl
movq %rdi, %r8
shlq $0xc, %r8
setne %r8b
testb %r8b, %cl
jne 0x6747
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq %rsi, %r8
notq %r8
testq %r8, %rax
setne %al
testq %rcx, %rsi
sete %cl
orb %al, %cl
je 0x6747
movq %rsi, %rax
xorq %rdi, %rax
js 0x6750
testq %rdi, %rdi
js 0x6765
cmpq %rsi, %rdi
setbe %al
jmp 0x674c
orb $0x10, (%rdx)
xorl %eax, %eax
movzbl %al, %eax
retq
testq %rdi, %rdi
sets %cl
btrq $0x3f, %rsi
orq %rdi, %rsi
sete %al
orb %cl, %al
jmp 0x674c
cmpq %rsi, %rdi
setae %al
jmp 0x674c
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: cvt_sf64_sf32
uint32_t glue(glue(cvt_sf, F_SIZE), _sf32)(F_UINT a, RoundingModeEnum rm,
                                           uint32_t *pfflags)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;

    a_mant = unpack_sf(&a_sign, &a_exp, a);
    if (a_exp == EXP_MASK) {
        if (a_mant != 0) {
            /* NaN */
            if (issignan_sf(a)) {
                *pfflags |= FFLAG_INVALID_OP;
            }
            return F_QNAN32;
        } else {
            /* infinity */
            return pack_sf32(a_sign, 0xff, 0);
        }
    }
    if (a_exp == 0) {
        if (a_mant == 0)
            return pack_sf32(a_sign, 0, 0); /* zero */
        normalize_subnormal_sf(&a_exp, a_mant);
    } else {
        a_mant |= (F_UINT)1 << MANT_SIZE;
    }
    /* convert the exponent value */
    a_exp = a_exp - (EXP_MASK / 2) + 0x7f;
    /* shift the mantissa */
    a_mant = rshift_rnd(a_mant, MANT_SIZE - (32 - 2));
    return normalize_sf32(a_sign, a_exp, a_mant, rm, pfflags);
}

// Assembly:
movq %rdx, %r8
movl %esi, %ecx
movq %rdi, %rax
movabsq $0xfffffffffffff, %rdx  # imm = 0xFFFFFFFFFFFFF
shrq $0x3f, %rdi
movq %rax, %rsi
shrq $0x34, %rsi
movq %rax, %r9
andq %rdx, %r9
andl $0x7ff, %esi            # imm = 0x7FF
je 0x694e
cmpl $0x7ff, %esi            # imm = 0x7FF
jne 0x695f
testq %r9, %r9
je 0x6985
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
andq %rcx, %rax
movl $0x7fc00000, %edi       # imm = 0x7FC00000
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0x6993
orb $0x10, (%r8)
jmp 0x6993
testq %r9, %r9
je 0x6990
bsrq %r9, %rsi
xorl $-0x40, %esi
addl $0xd, %esi
jmp 0x6965
addq %rdx, %r9
incq %r9
addl $0xfffffc80, %esi       # imm = 0xFFFFFC80
movq %r9, %rax
shrq $0x16, %rax
xorl %edx, %edx
testl $0x3fffff, %r9d         # imm = 0x3FFFFF
setne %dl
orl %eax, %edx
jmp 0x47c7
shll $0x1f, %edi
orl $0x7f800000, %edi       # imm = 0x7F800000
jmp 0x6993
shll $0x1f, %edi
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: divrem_u128
static F_UINT divrem_u(F_UINT *pr, F_UINT a1, F_UINT a0, F_UINT b)
{
    int i, qb, ab;

    assert(a1 < b);
    for(i = 0; i < F_SIZE; i++) {
        ab = a1 >> (F_SIZE - 1);
        a1 = (a1 << 1) | (a0 >> (F_SIZE - 1));
        if (ab || a1 >= b) {
            a1 -= b;
            qb = 1;
        } else {
            qb = 0;
        }
        a0 = (a0 << 1) | qb;
    }
    *pr = a1;
    return a0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rcx, %rsi
movq %rdx, %rax
sbbq %r8, %rax
jae 0x7e48
movq %rdx, %r9
movl $0x80, %r10d
xorl %eax, %eax
xorl %edx, %edx
subl $0x1, %r10d
jb 0x7e39
movq %r9, %r11
shldq $0x1, %rsi, %r11
shldq $0x1, %rdx, %rsi
testq %r9, %r9
sets %bl
cmpq %rcx, %rsi
movq %r11, %r9
sbbq %r8, %r9
setae %r9b
orb %bl, %r9b
movq %r8, %rbx
movq %rcx, %r14
jne 0x7e21
xorl %ebx, %ebx
xorl %r14d, %r14d
subq %r14, %rsi
sbbq %rbx, %r11
shldq $0x1, %rax, %rdx
movzbl %r9b, %r9d
leaq (%r9,%rax,2), %rax
movq %r11, %r9
jmp 0x7deb
movq %rsi, (%rdi)
movq %r9, 0x8(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc8d8(%rip), %rdi      # 0x14727
leaq 0xc6bb(%rip), %rsi      # 0x14511
leaq 0xc8d1(%rip), %rcx      # 0x1472e
movl $0x23b, %edx            # imm = 0x23B
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: cvt_sf128_sf64
uint64_t glue(glue(cvt_sf, F_SIZE), _sf64)(F_UINT a, RoundingModeEnum rm,
                                               uint32_t *pfflags)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;

    a_mant = unpack_sf(&a_sign, &a_exp, a);
    if (a_exp == EXP_MASK) {
        if (a_mant != 0) {
            /* NaN */
            if (issignan_sf(a)) {
                *pfflags |= FFLAG_INVALID_OP;
            }
            return F_QNAN64;
        } else {
            /* infinity */
            return pack_sf64(a_sign, 0x7ff, 0);
        }
    }
    if (a_exp == 0) {
        if (a_mant == 0)
            return pack_sf64(a_sign, 0, 0); /* zero */
        normalize_subnormal_sf(&a_exp, a_mant);
    } else {
        a_mant |= (F_UINT)1 << MANT_SIZE;
    }
    /* convert the exponent value */
    a_exp = a_exp - (EXP_MASK / 2) + 0x3ff;
    /* shift the mantissa */
    a_mant = rshift_rnd(a_mant, MANT_SIZE - (64 - 2));
    return normalize_sf64(a_sign, a_exp, a_mant, rm, pfflags);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
movq %rsi, %r13
shrq $0x30, %r13
movq %rsi, %r12
andq %rax, %r12
andl $0x7fff, %r13d          # imm = 0x7FFF
movl %r13d, 0x4(%rsp)
je 0x869d
cmpl $0x7fff, %r13d          # imm = 0x7FFF
jne 0x86be
orq %r15, %r12
je 0x86fe
movabsq $0x7ff8000000000000, %r12 # imm = 0x7FF8000000000000
movq %r15, %rdi
movq %r14, %rsi
callq 0x6e82
testl %eax, %eax
je 0x872a
orb $0x10, (%rbx)
jmp 0x872a
movq %r15, %rax
orq %r12, %rax
je 0x871a
leaq 0x4(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x73bb
movl (%r13), %r13d
jmp 0x86c4
addq %rax, %r12
incq %r12
shrq $0x3f, %r14
addl $0xffffc400, %r13d      # imm = 0xFFFFC400
pushq $0x32
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x706a
movl %r14d, %edi
movl %r13d, %esi
movq %rax, %rdx
movl %ebp, %ecx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5a35
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %r14
movabsq $0x7ff0000000000000, %r12 # imm = 0x7FF0000000000000
orq %r14, %r12
jmp 0x872a
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %r14
movq %r14, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_squash_input_denormal
float32 float32_squash_input_denormal(float32 a, float_status *status)
{
    if (status->flush_inputs_to_zero) {
        if (extractFloat32Exp(a) == 0 && extractFloat32Frac(a) != 0) {
            float_raise(float_flag_input_denormal, status);
            return make_float32(float32_val(a) & 0x80000000);
        }
    }
    return a;
}

// Assembly:
movl %edi, %eax
cmpb $0x0, 0x5(%rsi)
je 0x920c
testl $0x7f800000, %eax       # imm = 0x7F800000
setne %cl
testl $0x7fffff, %eax         # imm = 0x7FFFFF
sete %dl
orb %cl, %dl
jne 0x920c
orb $0x40, 0x2(%rsi)
andl $0x80000000, %eax       # imm = 0x80000000
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_squash_input_denormal
float64 float64_squash_input_denormal(float64 a, float_status *status)
{
    if (status->flush_inputs_to_zero) {
        if (extractFloat64Exp(a) == 0 && extractFloat64Frac(a) != 0) {
            float_raise(float_flag_input_denormal, status);
            return make_float64(float64_val(a) & (1ULL << 63));
        }
    }
    return a;
}

// Assembly:
movq %rdi, %rax
cmpb $0x0, 0x5(%rsi)
je 0x9245
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
testq %rcx, %rax
setne %cl
movq %rax, %rdx
shlq $0xc, %rdx
sete %dl
orb %cl, %dl
jne 0x9245
orb $0x40, 0x2(%rsi)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
andq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: int32_to_float64
float64 int32_to_float64(int32_t a, float_status *status)
{
    flag zSign;
    uint32 absA;
    int8 shiftCount;
    uint64_t zSig;

    if ( a == 0 ) return float64_zero;
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros32( absA ) + 21;
    zSig = absA;
    return packFloat64( zSign, 0x432 - shiftCount, zSig<<shiftCount );

}

// Assembly:
testl %edi, %edi
je 0x92d1
movl %edi, %edx
shrl $0x1f, %edx
movl %edi, %esi
negl %esi
cmovsl %edi, %esi
bsrl %esi, %ecx
xorl $0x1f, %ecx
addl $0x15, %ecx
shlq %cl, %rsi
shlq $0x3f, %rdx
movabsq $0x4320000000000000, %rax # imm = 0x4320000000000000
orq %rdx, %rax
shlq $0x34, %rcx
subq %rcx, %rax
addq %rsi, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: int32_to_floatx80
floatx80 int32_to_floatx80(int32_t a, float_status *status)
{
    flag zSign;
    uint32 absA;
    int8 shiftCount;
    uint64_t zSig;

    if ( a == 0 ) return packFloatx80( 0, 0, 0 );
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros32( absA ) + 32;
    zSig = absA;
    return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );

}

// Assembly:
testl %edi, %edi
je 0x9301
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
orb $0x20, %cl
movzbl %cl, %ecx
shlq %cl, %rax
shrl $0x10, %edi
andl $0x8000, %edi           # imm = 0x8000
subl %ecx, %edi
addl $0x403e, %edi           # imm = 0x403E
jmp 0x9305
xorl %eax, %eax
xorl %edi, %edi
movl %edi, %edx
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: int32_to_float128
float128 int32_to_float128(int32_t a, float_status *status)
{
    flag zSign;
    uint32 absA;
    int8 shiftCount;
    uint64_t zSig0;

    if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros32( absA ) + 17;
    zSig0 = absA;
    return packFloat128( zSign, 0x402E - shiftCount, zSig0<<shiftCount, 0 );

}

// Assembly:
testl %edi, %edi
je 0x9342
movl %edi, %eax
shrl $0x1f, %eax
movl %edi, %edx
negl %edx
cmovsl %edi, %edx
bsrl %edx, %ecx
xorl $0x1f, %ecx
addl $0x11, %ecx
shlq %cl, %rdx
shlq $0x3f, %rax
addq %rdx, %rax
shlq $0x30, %rcx
subq %rcx, %rax
movabsq $0x402e000000000000, %rdx # imm = 0x402E000000000000
addq %rax, %rdx
xorl %eax, %eax
retq
xorl %eax, %eax
xorl %edx, %edx
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: int64_to_float32
float32 int64_to_float32(int64_t a, float_status *status)
{
    flag zSign;
    uint64 absA;
    int8 shiftCount;

    if ( a == 0 ) return float32_zero;
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros64( absA ) - 40;
    if ( 0 <= shiftCount ) {
        return packFloat32( zSign, 0x95 - shiftCount, absA<<shiftCount );
    }
    else {
        shiftCount += 7;
        if ( shiftCount < 0 ) {
            shift64RightJamming( absA, - shiftCount, &absA );
        }
        else {
            absA <<= shiftCount;
        }
        return roundAndPackFloat32(zSign, 0x9C - shiftCount, absA, status);
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9393
movq %rdi, %rbx
shrq $0x3f, %rbx
movq %rdi, %rdx
negq %rdx
cmovsq %rdi, %rdx
movq %rdx, (%rsp)
bsrq %rdx, %rcx
xorl $0x3f, %ecx
cmpq $0xffffff, %rdx         # imm = 0xFFFFFF
ja 0x93a2
addb $-0x28, %cl
movzbl %cl, %ecx
shlq %cl, %rdx
shll $0x1f, %ebx
orl $0x4a800000, %ebx       # imm = 0x4A800000
shll $0x17, %ecx
subl %ecx, %ebx
addl %edx, %ebx
jmp 0x9395
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
addb $-0x21, %cl
movsbl %cl, %ebp
movq %rdx, %rax
shrq $0x1f, %rax
je 0x93cb
movl %ebp, %esi
negl %esi
movq %rsp, %r15
movq %rdx, %rdi
movq %r15, %rdx
callq 0x93e7
movq (%r15), %rdx
jmp 0x93ce
shlq %cl, %rdx
movl $0x9c, %esi
subl %ebp, %esi
movzbl %bl, %edi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9421
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift64RightJamming
static inline void shift64RightJamming(uint64_t a, int_fast16_t count, uint64_t *zPtr)
{
    uint64_t z;

    if ( count == 0 ) {
        z = a;
    }
    else if ( count < 64 ) {
        z = ( a>>count ) | ( ( a<<( ( - count ) & 63 ) ) != 0 );
    }
    else {
        z = ( a != 0 );
    }
    *zPtr = z;

}

// Assembly:
testq %rsi, %rsi
je 0x941d
cmpq $0x3f, %rsi
jg 0x9412
movq %rdi, %rax
movl %esi, %ecx
shrq %cl, %rax
negb %sil
movl %esi, %ecx
shlq %cl, %rdi
xorl %ecx, %ecx
testq %rdi, %rdi
setne %cl
orq %rax, %rcx
movq %rcx, %rdi
jmp 0x941d
xorl %eax, %eax
testq %rdi, %rdi
setne %al
movq %rax, %rdi
movq %rdi, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: int64_to_floatx80
floatx80 int64_to_floatx80(int64_t a, float_status *status)
{
    flag zSign;
    uint64 absA;
    int8 shiftCount;

    if ( a == 0 ) return packFloatx80( 0, 0, 0 );
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros64( absA );
    return packFloatx80( zSign, 0x403E - shiftCount, absA<<shiftCount );

}

// Assembly:
testq %rdi, %rdi
je 0x95e9
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
bsrq %rax, %rcx
xorq $0x3f, %rcx
shlq %cl, %rax
shrq $0x30, %rdi
andl $0x8000, %edi           # imm = 0x8000
subl %ecx, %edi
addl $0x403e, %edi           # imm = 0x403E
jmp 0x95ed
xorl %eax, %eax
xorl %edi, %edi
movl %edi, %edx
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: int64_to_float128
float128 int64_to_float128(int64_t a, float_status *status)
{
    flag zSign;
    uint64 absA;
    int8 shiftCount;
    int32 zExp;
    uint64_t zSig0, zSig1;

    if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );
    zSign = ( a < 0 );
    absA = zSign ? - a : a;
    shiftCount = countLeadingZeros64( absA ) + 49;
    zExp = 0x406E - shiftCount;
    if ( 64 <= shiftCount ) {
        zSig1 = 0;
        zSig0 = absA;
        shiftCount -= 64;
    }
    else {
        zSig1 = absA;
        zSig0 = 0;
    }
    shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
    return packFloat128( zSign, zExp, zSig0, zSig1 );

}

// Assembly:
testq %rdi, %rdi
je 0x9667
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
andq %rdi, %rdx
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
bsrq %rax, %rcx
xorl $0x3f, %ecx
leal 0x31(%rcx), %edi
movq %rax, %r8
shrq $0x31, %r8
addb $-0xf, %cl
xorl %esi, %esi
testq %r8, %r8
cmoveq %rax, %rsi
movzbl %dil, %edi
cmovneq %rax, %r8
movzbl %cl, %ecx
cmovnel %edi, %ecx
movq %r8, %rax
shlq %cl, %rax
testb %cl, %cl
je 0x964f
movzbl %cl, %ecx
shlq %cl, %rsi
negb %cl
shrq %cl, %r8
orq %r8, %rsi
movabsq $0x406e000000000000, %rcx # imm = 0x406E000000000000
orq %rcx, %rdx
shlq $0x30, %rdi
subq %rdi, %rdx
addq %rsi, %rdx
retq
xorl %eax, %eax
xorl %edx, %edx
retq
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/softfloat.c
// Function: uint64_to_float32
float32 uint64_to_float32(uint64_t a, float_status *status)
{
    int shiftcount;

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

    /* Determine (left) shift needed to put first set bit into bit posn 23
     * (since packFloat32() expects the binary point between bits 23 and 22);
     * this is the fast case for smallish numbers.
     */
    shiftcount = countLeadingZeros64(a) - 40;
    if (shiftcount >= 0) {
        return packFloat32(0, 0x95 - shiftcount, a << shiftcount);
    }
    /* Otherwise we need to do a round-and-pack. roundAndPackFloat32()
     * expects the binary point between bits 30 and 29, hence the + 7.
     */
    shiftcount += 7;
    if (shiftcount < 0) {
        shift64RightJamming(a, -shiftcount, &a);
    } else {
        a <<= shiftcount;
    }

    return roundAndPackFloat32(0, 0x9c - shiftcount, a, status);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x96ac
movq %rdi, %rax
bsrq %rdi, %r15
xorq $0x3f, %r15
cmpq $0xffffff, %rdi         # imm = 0xFFFFFF
ja 0x96b8
movl $0xffffffd8, %ecx       # imm = 0xFFFFFFD8
addl %r15d, %ecx
shlq %cl, %rax
shll $0x17, %r15d
subl %r15d, %eax
addl $0x5e800000, %eax       # imm = 0x5E800000
jmp 0x96ae
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %rbx
movq %rax, %rcx
shrq $0x1f, %rcx
je 0x96df
pushq $0x21
popq %rsi
subl %r15d, %esi
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x93e7
movq (%r14), %rax
jmp 0x96e6
leal -0x21(%r15), %ecx
shlq %cl, %rax
movl $0xbd, %esi
subq %r15, %rsi
xorl %edi, %edi
movl %eax, %edx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x9421
// File: /workspace/github_c_makefile_star2_O2/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 0x9720
movq %rsi, %rax
movq %rdi, %rdx
bsrq %rdi, %rdi
xorq $0x3f, %rdi
je 0x9723
leal -0x1(%rdi), %ecx
shlq %cl, %rdx
jmp 0x972f
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 0x973e
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %rax
movl %esi, %ebp
movl %edi, %ebx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
testq %rdx, %rdx
je 0x9913
movq %rax, %rsi
movq %rdx, %rax
jmp 0x9923
andq $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
addl $-0x40, %ebp
xorl %esi, %esi
testq %rax, %rax
je 0x9932
bsrq %rax, %rcx
xorq $0x3f, %rcx
jmp 0x9935
pushq $0x40
popq %rcx
addb $-0xf, %cl
movsbl %cl, %r13d
movq %rax, %rdx
shrq $0x31, %rdx
jne 0x9962
movq %rsi, %r9
shlq %cl, %r9
testb %cl, %cl
je 0x995d
movslq %r13d, %rcx
shlq %cl, %rax
negb %cl
shrq %cl, %rsi
orq %rsi, %rax
xorl %r8d, %r8d
jmp 0x9999
movl %r13d, %ecx
negl %ecx
leaq 0x20(%rsp), %rdx
movq %rdx, (%rsp)
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %rax, %rdi
xorl %edx, %edx
movq %r15, %r8
movq %r12, %r9
callq 0x1156d
movq (%r15), %rax
movq (%r12), %r9
leaq 0x20(%rsp), %rcx
movq (%rcx), %r8
subl %r13d, %ebp
movzbl %bl, %edi
movl %ebp, %esi
movq %rax, %rdx
movq %r9, %rcx
movq %r14, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x115fc
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x91e7
movl %eax, %ebp
movl %eax, %r15d
andl $0x7fffff, %r15d        # imm = 0x7FFFFF
shrl $0x17, %eax
movzbl %al, %r12d
leal 0x800000(%r15), %esi
testl %r12d, %r12d
cmovel %r15d, %esi
shlq $0x20, %rsi
movq %rsi, 0x8(%rsp)
cmpl $0xae, %r12d
ja 0x9a25
movl %r12d, %ecx
movl $0xaf, %eax
subq %rcx, %rax
leaq 0x8(%rsp), %r14
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x93e7
movq (%r14), %rsi
shrl $0x1f, %ebp
xorl %edi, %edi
cmpl $0xff, %r12d
cmovnel %ebp, %edi
testl %r15d, %r15d
cmovel %ebp, %edi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9a4b
// File: /workspace/github_c_makefile_star2_O2/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 0x9af3
leaq 0xad48(%rip), %rcx      # 0x147a8
movslq (%rcx,%rax,4), %r8
addq %rcx, %r8
jmpq *%r8
pushq $0x40
popq %rcx
jmp 0x9a8f
xorl %ecx, %ecx
jmp 0x9a8f
xorl %r8d, %r8d
testb %dil, %dil
pushq $0x7f
popq %rcx
cmoveq %r8, %rcx
jmp 0x9a8f
xorl %r8d, %r8d
testb %dil, %dil
pushq $0x7f
popq %rcx
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 0x9ae2
testl %eax, %eax
je 0x9ad8
movl %eax, %ecx
shrl $0x1f, %ecx
movzbl %dil, %esi
cmpl %esi, %ecx
jne 0x9ae2
testb %r8b, %r8b
je 0x9ae1
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_O2/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:
pushq %rbx
movq %rsi, %rbx
callq 0x91e7
movl %eax, %esi
andl $0x7fffff, %esi         # imm = 0x7FFFFF
movl %eax, %edx
shrl $0x17, %edx
movzbl %dl, %edi
cmpl $0x9e, %edi
jb 0x9b28
cmpl $0xcf000000, %eax       # imm = 0xCF000000
jne 0x9b39
movl $0x80000000, %ecx       # imm = 0x80000000
jmp 0x9b83
cmpl $0x7e, %edi
ja 0x9b5a
xorl %ecx, %ecx
orl %esi, %edi
je 0x9b83
orb $0x20, 0x2(%rbx)
jmp 0x9b83
orb $0x1, 0x2(%rbx)
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
testl %eax, %eax
jns 0x9b83
cmpl $0xff, %edi
sete %al
testl %esi, %esi
setne %dl
testb %al, %dl
je 0x9b21
jmp 0x9b83
shll $0x8, %esi
orl $0x80000000, %esi       # imm = 0x80000000
movb $-0x62, %cl
subb %dl, %cl
movl %esi, %edi
shrl %cl, %edi
addb $0x2, %dl
movl %edx, %ecx
shll %cl, %esi
testl %esi, %esi
je 0x9b7a
orb $0x20, 0x2(%rbx)
movl %edi, %ecx
negl %ecx
testl %eax, %eax
cmovnsl %edi, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9baf
cmpl $0xc7000000, %edi       # imm = 0xC7000000
jne 0x9bbf
movq $-0x8000, %rax          # imm = 0x8000
retq
cmpl $0x7e, %ecx
ja 0x9bcd
orl %edx, %ecx
je 0x9bbc
orb $0x20, 0x2(%rsi)
xorl %eax, %eax
retq
orb $0x1, 0x2(%rsi)
movl $0x7fff, %eax           # imm = 0x7FFF
testl %edi, %edi
js 0x9bfc
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 0x9bee
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 0x9ba7
jmp 0x9bcc
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
callq 0x91e7
movl %eax, %ebp
movl %eax, %ecx
andl $0x7fffff, %ecx         # imm = 0x7FFFFF
shrl $0x17, %eax
movzbl %al, %esi
cmpl $0xbf, %esi
jb 0x9c6b
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
orb $0x1, 0x2(%rbx)
testl %ebp, %ebp
jns 0x9c60
leaq 0x1(%rax), %rdx
cmpl $0xff, %esi
cmovneq %rdx, %rax
testl %ecx, %ecx
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %eax
shrl $0x1f, %ebp
movl $0xbe, %edx
subq %rax, %rdx
leal 0x800000(%rcx), %edi
testl %esi, %esi
cmovel %ecx, %edi
shlq $0x28, %rdi
leaq 0x10(%rsp), %r14
movq %rdi, (%r14)
leaq 0x8(%rsp), %r15
xorl %esi, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x9cb8
movq (%r14), %rsi
movq (%r15), %rdx
movl %ebp, %edi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9d0f
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift64ExtraRightJamming
static inline void
 shift64ExtraRightJamming(
     uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
{
    uint64_t z0, z1;
    int8 negCount = ( - count ) & 63;

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

}

// Assembly:
movq %rcx, %rax
testq %rdx, %rdx
je 0x9d08
cmpq $0x3f, %rdx
jg 0x9cea
movl %edx, %ecx
negl %ecx
andl $0x3f, %ecx
movq %rdi, %r9
shlq %cl, %r9
xorl %r10d, %r10d
testq %rsi, %rsi
setne %r10b
orq %r9, %r10
movl %edx, %ecx
shrq %cl, %rdi
movq %r10, %rsi
jmp 0x9d08
xorl %ecx, %ecx
cmpq $0x40, %rdx
jne 0x9cfd
testq %rsi, %rsi
setne %cl
orq %rdi, %rcx
jmp 0x9d03
orq %rdi, %rsi
setne %cl
xorl %edi, %edi
movq %rcx, %rsi
movq %rsi, (%r8)
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9dc2
leaq 0xaa98(%rip), %r8       # 0x147bc
movslq (%r8,%rax,4), %r9
addq %r8, %r9
jmpq *%r9
movq %rdx, %r8
shrq $0x3f, %r8
jmp 0x9d51
testb %dil, %dil
sete %r9b
jmp 0x9d47
testb %dil, %dil
setne %r9b
testq %rdx, %rdx
setne %r8b
andb %r9b, %r8b
testb %r8b, %r8b
je 0x9d7c
incq %rsi
je 0x9da8
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 0x9d9e
movq %rax, %rsi
shrq $0x3f, %rsi
movzbl %dil, %r8d
cmpl %r8d, %esi
jne 0x9da8
testq %rdx, %rdx
je 0x9da7
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_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
callq 0x91e7
movl %eax, %ecx
shrl $0x17, %ecx
movzbl %cl, %ecx
testl %eax, %eax
setns %dl
cmpl $0x7f, %ecx
setb %sil
orb %dl, %sil
jne 0x9e09
orb $0x1, 0x2(%rbx)
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpl $0x7f800001, %eax       # imm = 0x7F800001
adcq $-0x1, %rcx
jmp 0x9e18
cmpl $0xbf, %ecx
jb 0x9e26
orb $0x1, 0x2(%rbx)
pushq $-0x1
popq %rcx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
shrl $0x1f, %ebp
movl %ecx, %esi
andl $0x7fffff, %eax         # imm = 0x7FFFFF
leal 0x800000(%rax), %edi
testl %ecx, %ecx
cmovel %eax, %edi
movl $0xbe, %edx
subq %rsi, %rdx
shlq $0x28, %rdi
leaq 0x10(%rsp), %r14
movq %rdi, (%r14)
leaq 0x8(%rsp), %r15
xorl %esi, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x9cb8
movq (%r14), %rsi
movq (%r15), %rdx
movzbl %bpl, %edi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9e7c
// File: /workspace/github_c_makefile_star2_O2/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 0x9f0c
leaq 0xa93f(%rip), %r8       # 0x147d0
movslq (%r8,%rax,4), %r9
addq %r8, %r9
jmpq *%r9
movq %rdx, %r8
shrq $0x3f, %r8
jmp 0x9ebe
testb %dil, %dil
sete %r9b
jmp 0x9eb4
testb %dil, %dil
setne %r9b
testq %rdx, %rdx
setne %r8b
andb %r9b, %r8b
testb %r8b, %r8b
je 0x9eee
incq %rsi
jne 0x9ecd
pushq $-0x1
popq %rsi
jmp 0x9efa
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 0x9efe
testq %rsi, %rsi
je 0x9efe
xorl %esi, %esi
movb $0x1, %al
jmp 0x9f05
movb $0x20, %al
testq %rdx, %rdx
je 0x9f08
orb %al, 0x2(%rcx)
movq %rsi, %rax
retq
pushq %rax
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 0x9dc8
movb %bpl, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rsi, %rbx
callq 0x91e7
movl %eax, %esi
andl $0x7fffff, %esi         # imm = 0x7FFFFF
movl %eax, %ecx
shrl $0x17, %ecx
movzbl %cl, %edi
cmpl $0xbe, %edi
jb 0x9f67
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpl $0xdf000000, %eax       # imm = 0xDF000000
jne 0x9f78
incq %rcx
jmp 0x9fc7
cmpl $0x7e, %edi
ja 0x9f94
orl %edi, %esi
je 0x9f74
orb $0x20, 0x2(%rbx)
xorl %ecx, %ecx
jmp 0x9fc7
orb $0x1, 0x2(%rbx)
testl %eax, %eax
jns 0x9fc7
cmpl $0xff, %edi
sete %al
testl %esi, %esi
setne %dl
testb %al, %dl
je 0x9f62
jmp 0x9fc7
leaq 0x2(%rdi), %rdx
orl $0x800000, %esi         # imm = 0x800000
shlq $0x28, %rsi
movb $-0x42, %cl
subb %dil, %cl
movq %rsi, %rdi
shrq %cl, %rdi
movl %edx, %ecx
shlq %cl, %rsi
testq %rsi, %rsi
je 0x9fbb
orb $0x20, 0x2(%rbx)
movq %rdi, %rcx
negq %rcx
testl %eax, %eax
cmovnsq %rdi, %rcx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
callq 0x91e7
movl %eax, %esi
movl %eax, %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl %eax, %ecx
shrl $0x17, %ecx
shrl $0x1f, %eax
testb %cl, %cl
je 0xa057
movzbl %cl, %ecx
cmpl $0xff, %ecx
jne 0xa06e
movabsq $0x7ff0000000000000, %r15 # imm = 0x7FF0000000000000
testl %edx, %edx
je 0xa099
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xa0a8
movq 0x8(%r14), %rcx
movq %rcx, %rdx
shrq $0xc, %rdx
movl (%r14), %eax
shlq $0x3f, %rax
orq %rdx, %rax
orq %r15, %rax
cmpq $0x1000, %rcx           # imm = 0x1000
movabsq $0x7ff8000000000000, %rcx # imm = 0x7FF8000000000000
cmovbq %rcx, %rax
cmpb $0x0, 0x6(%rbx)
cmovneq %rcx, %rax
jmp 0xa08f
testl %edx, %edx
je 0xa0a2
bsrl %edx, %esi
xorl $0x1f, %esi
leal -0x8(%rsi), %ecx
shll %cl, %edx
pushq $0x8
popq %rcx
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
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
shlq $0x3f, %rax
orq %r15, %rax
jmp 0xa08f
shlq $0x3f, %rax
jmp 0xa08f
// File: /workspace/github_c_makefile_star2_O2/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float32ToCommonNaN
static commonNaNT float32ToCommonNaN(float32 a, float_status *status)
{
    commonNaNT z;

    if (float32_is_signaling_nan(a)) {
        float_raise(float_flag_invalid, status);
    }
    z.sign = float32_val(a)>>31;
    z.low = 0;
    z.high = ( (uint64_t) float32_val(a) )<<41;
    return z;
}

// Assembly:
movq %rdi, %rax
movl %esi, %ecx
andl $0x7fc00000, %ecx       # imm = 0x7FC00000
cmpl $0x7f800000, %ecx       # imm = 0x7F800000
setne %cl
testl $0x3fffff, %esi         # imm = 0x3FFFFF
sete %dil
orb %cl, %dil
jne 0xa0cf
orb $0x1, 0x2(%rdx)
movl %esi, %ecx
shrl $0x1f, %ecx
movb %cl, (%rax)
andq $0x0, 0x10(%rax)
shlq $0x29, %rsi
movq %rsi, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
callq 0x91e7
movl %eax, %ebx
andl $0x7fffff, %ebx         # imm = 0x7FFFFF
movl %eax, %ecx
shrl $0x17, %ecx
movl %eax, %edx
shrl $0x1f, %edx
testb %cl, %cl
je 0xa15e
movzbl %cl, %ecx
cmpl $0xff, %ecx
jne 0xa172
testl %ebx, %ebx
je 0xa192
movabsq $-0x4000000000000000, %rbx # imm = 0xC000000000000000
movq %rsp, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xa0a8
movw $0xffff, %dx            # imm = 0xFFFF
cmpb $0x0, 0x6(%r14)
jne 0xa187
movq 0x8(%rsp), %rax
cmpq $0x2, %rax
jb 0xa187
shrq %rax
btsq $0x3f, %rax
movl (%rsp), %edx
shll $0xf, %edx
orl $0x7fff, %edx           # imm = 0x7FFF
movq %rax, %rbx
jmp 0xa187
testl %ebx, %ebx
je 0xa1a7
bsrl %ebx, %eax
xorl $0x1f, %eax
leal -0x8(%rax), %ecx
shll %cl, %ebx
pushq $0x9
popq %rcx
subl %eax, %ecx
orl $0x800000, %ebx         # imm = 0x800000
shlq $0x28, %rbx
shll $0xf, %edx
addl %ecx, %edx
addl $0x3f80, %edx           # imm = 0x3F80
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
shll $0xf, %edx
orl $0x7fff, %edx           # imm = 0x7FFF
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
jmp 0xa187
shll $0xf, %edx
xorl %ebx, %ebx
jmp 0xa187
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
callq 0x91e7
movl %eax, %edi
andl $0x7fffff, %edi         # imm = 0x7FFFFF
movl %eax, %ecx
shrl $0x17, %ecx
movl %eax, %esi
shrl $0x1f, %esi
testb %cl, %cl
je 0xa201
movzbl %cl, %edx
cmpl $0xff, %edx
jne 0xa215
testl %edi, %edi
je 0xa237
leaq 0x8(%rsp), %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0xa0a8
cmpb $0x0, 0x6(%rbx)
je 0xa255
movabsq $0x7fff800000000000, %rdx # imm = 0x7FFF800000000000
jmp 0xa22f
testl %edi, %edi
je 0xa24a
bsrl %edi, %eax
xorl $0x1f, %eax
leal -0x8(%rax), %ecx
shll %cl, %edi
pushq $0x8
popq %rdx
subl %eax, %edx
addl $0x3f80, %edx           # imm = 0x3F80
movl %edi, %eax
shlq $0x19, %rax
shlq $0x3f, %rsi
orq %rax, %rsi
shlq $0x30, %rdx
addq %rsi, %rdx
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
shlq $0x3f, %rsi
movabsq $0x7fff000000000000, %rdx # imm = 0x7FFF000000000000
orq %rsi, %rdx
jmp 0xa22f
shlq $0x3f, %rsi
xorl %eax, %eax
movq %rsi, %rdx
jmp 0xa231
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
shrdq $0x10, %rcx, %rax
shrq $0x10, %rcx
movl 0x8(%rsp), %esi
shlq $0x3f, %rsi
orq %rcx, %rsi
movabsq $0x7fff000000000000, %rdx # imm = 0x7FFF000000000000
orq %rsi, %rdx
jmp 0xa231