LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float64_is_signaling_nan
int float64_is_signaling_nan( float64 a_ )
{
    uint64_t a = float64_val(a_);
#if SNAN_BIT_IS_ONE
    return ((a << 1) >= 0xfff0000000000000ULL);
#else
    return
           ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
        && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
shrq $0x33, %rcx
andq $0xfff, %rcx            # imm = 0xFFF
xorl %eax, %eax
cmpq $0xffe, %rcx            # imm = 0xFFE
movb %al, -0x11(%rbp)
jne 0x112b5
movabsq $0x7ffffffffffff, %rax  # imm = 0x7FFFFFFFFFFFF
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float64_maybe_silence_nan
float64 float64_maybe_silence_nan( float64 a_ )
{
    if (float64_is_signaling_nan(a_)) {
#if SNAN_BIT_IS_ONE
#  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
        return float64_default_nan;
#  else
#    error Rules for silencing a signaling NaN are target-specific
#  endif
#else
        uint64_t a = float64_val(a_);
        a |= LIT64( 0x0008000000000000 );
        return make_float64(a);
#endif
    }
    return a_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11270
cmpl $0x0, %eax
je 0x112fe
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0x8000000000000, %rax  # imm = 0x8000000000000
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11306
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: floatx80_is_quiet_nan
int floatx80_is_quiet_nan( floatx80 a )
{
#if SNAN_BIT_IS_ONE
    uint64_t aLow;

    aLow = a.low & ~0x4000000000000000ULL;
    return ((a.high & 0x7fff) == 0x7fff)
        && (aLow << 1)
        && (a.low == aLow);
#else
    return ( ( a.high & 0x7FFF ) == 0x7FFF )
        && (LIT64( 0x8000000000000000 ) <= ((uint64_t) ( a.low<<1 )));
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x8(%rbp)
movzwl -0x8(%rbp), %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
xorl %eax, %eax
cmpl $0x7fff, %ecx           # imm = 0x7FFF
movb %al, -0x11(%rbp)
jne 0x11350
movq -0x10(%rbp), %rcx
shlq %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rcx, %rax
setbe %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: floatx80_is_signaling_nan
int floatx80_is_signaling_nan( floatx80 a )
{
#if SNAN_BIT_IS_ONE
    return ((a.high & 0x7fff) == 0x7fff)
        && ((a.low << 1) >= 0x8000000000000000ULL);
#else
    uint64_t aLow;

    aLow = a.low & ~ LIT64( 0x4000000000000000 );
    return
           ( ( a.high & 0x7FFF ) == 0x7FFF )
        && (uint64_t) ( aLow<<1 )
        && ( a.low == aLow );
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x8(%rbp)
movabsq $-0x4000000000000001, %rax # imm = 0xBFFFFFFFFFFFFFFF
andq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0x8(%rbp), %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
xorl %eax, %eax
cmpl $0x7fff, %ecx           # imm = 0x7FFF
movb %al, -0x19(%rbp)
jne 0x113b8
movq -0x18(%rbp), %rcx
shlq %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
je 0x113b8
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: floatx80_maybe_silence_nan
floatx80 floatx80_maybe_silence_nan( floatx80 a )
{
    if (floatx80_is_signaling_nan(a)) {
#if SNAN_BIT_IS_ONE
#  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
        a.low = floatx80_default_nan_low;
        a.high = floatx80_default_nan_high;
#  else
#    error Rules for silencing a signaling NaN are target-specific
#  endif
#else
        a.low |= LIT64( 0xC000000000000000 );
        return a;
#endif
    }
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x20(%rbp)
movw %ax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movzwl -0x18(%rbp), %esi
callq 0x11360
cmpl $0x0, %eax
je 0x11419
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11429
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movw -0x8(%rbp), %dx
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float128_is_quiet_nan
int float128_is_quiet_nan( float128 a )
{
#if SNAN_BIT_IS_ONE
    return (((a.high >> 47) & 0xffff) == 0xfffe)
        && (a.low || (a.high & 0x00007fffffffffffULL));
#else
    return
        ((a.high << 1) >= 0xffff000000000000ULL)
        && (a.low || (a.high & 0x0000ffffffffffffULL));
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
shlq %rcx
xorl %eax, %eax
movabsq $-0x1000000000000, %rdx # imm = 0xFFFF000000000000
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jb 0x11491
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x12(%rbp)
jne 0x1148b
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq -0x8(%rbp), %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float128_is_signaling_nan
int float128_is_signaling_nan( float128 a )
{
#if SNAN_BIT_IS_ONE
    return
        ((a.high << 1) >= 0xffff000000000000ULL)
        && (a.low || (a.high & 0x0000ffffffffffffULL));
#else
    return
           ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
        && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
shrq $0x2f, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
xorl %eax, %eax
cmpq $0xfffe, %rcx           # imm = 0xFFFE
movb %al, -0x11(%rbp)
jne 0x114f3
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x12(%rbp)
jne 0x114ed
movabsq $0x7fffffffffff, %rax   # imm = 0x7FFFFFFFFFFF
andq -0x8(%rbp), %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float128_maybe_silence_nan
float128 float128_maybe_silence_nan( float128 a )
{
    if (float128_is_signaling_nan(a)) {
#if SNAN_BIT_IS_ONE
#  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
        a.low = float128_default_nan_low;
        a.high = float128_default_nan_high;
#  else
#    error Rules for silencing a signaling NaN are target-specific
#  endif
#else
        a.high |= LIT64( 0x0000800000000000 );
        return a;
#endif
    }
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x114a0
cmpl $0x0, %eax
je 0x11546
movabsq $0x800000000000, %rax   # imm = 0x800000000000
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11556
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x5(%rax)
je 0x115c1
movl -0x8(%rbp), %edi
callq 0x115d0
cmpq $0x0, %rax
jne 0x115bf
movl -0x8(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
je 0x115bf
movq -0x10(%rbp), %rsi
movl $0x40, %edi
callq 0x11080
movl -0x8(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x4(%rbp)
jmp 0x115c7
jmp 0x115c1
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x5(%rax)
je 0x1166c
movq -0x10(%rbp), %rdi
callq 0x11680
cmpq $0x0, %rax
jne 0x1166a
movq -0x10(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
je 0x1166a
movq -0x18(%rbp), %rsi
movl $0x40, %edi
callq 0x11080
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11674
jmp 0x1166c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: int32_to_float32
float32 int32_to_float32(int32_t a, float_status *status)
{
    flag zSign;

    if ( a == 0 ) return float32_zero;
    if ( a == (int32_t) 0x80000000 ) return packFloat32( 1, 0x9E, 0 );
    zSign = ( a < 0 );
    return normalizeRoundAndPackFloat32(zSign, 0x9C, zSign ? -a : a, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x116de
movl $0x0, -0x4(%rbp)
jmp 0x11745
cmpl $0x80000000, -0x8(%rbp) # imm = 0x80000000
jne 0x116fd
movl $0x1, %edi
movl $0x9e, %esi
xorl %edx, %edx
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x11745
cmpl $0x0, -0x8(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x12(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0x11725
xorl %eax, %eax
subl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1172b
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
movb -0x12(%rbp), %al
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rcx
movl $0x9c, %esi
movzbl %al, %edi
callq 0x11780
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: normalizeRoundAndPackFloat32
static float32
 normalizeRoundAndPackFloat32(flag zSign, int_fast16_t zExp, uint32_t zSig,
                              float_status *status)
{
    int8 shiftCount;

    shiftCount = countLeadingZeros32( zSig ) - 1;
    return roundAndPackFloat32(zSign, zExp - shiftCount, zSig<<shiftCount,
                               status);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x11880
movsbl %al, %eax
subl $0x1, %eax
movb %al, -0x21(%rbp)
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rsi
movsbq -0x21(%rbp), %rcx
subq %rcx, %rsi
movl -0x14(%rbp), %edx
movsbl -0x21(%rbp), %ecx
shll %cl, %edx
movq -0x20(%rbp), %rcx
movzbl %al, %edi
callq 0x11cb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x117ff
movq $0x0, -0x8(%rbp)
jmp 0x1186f
cmpl $0x0, -0xc(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x11821
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x11827
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x11880
movsbl %al, %eax
addl $0x15, %eax
movb %al, -0x21(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x30(%rbp)
movb -0x19(%rbp), %al
movsbl -0x21(%rbp), %edx
movl $0x432, %ecx            # imm = 0x432
subl %edx, %ecx
movslq %ecx, %rsi
movq -0x30(%rbp), %rdx
movsbl -0x21(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movzbl %al, %edi
callq 0x118b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1190c
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl %esi, %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x1197d
cmpl $0x0, -0x14(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x1192e
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x11934
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x11880
movsbl %al, %eax
addl $0x20, %eax
movb %al, -0x29(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x38(%rbp)
movb -0x21(%rbp), %al
movsbl -0x29(%rbp), %ecx
movl $0x403e, %esi           # imm = 0x403E
subl %ecx, %esi
movq -0x38(%rbp), %rdx
movsbl -0x29(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movzbl %al, %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movw -0x8(%rbp), %dx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x119ff
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
movl %esi, %edi
movq %rcx, %rdx
callq 0x11a80
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x11a72
cmpl $0x0, -0x14(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x11a21
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x11a27
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x11880
movsbl %al, %eax
addl $0x11, %eax
movb %al, -0x29(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x38(%rbp)
movb -0x21(%rbp), %al
movsbl -0x29(%rbp), %ecx
movl $0x402e, %esi           # imm = 0x402E
subl %ecx, %esi
movq -0x38(%rbp), %rdx
movsbl -0x29(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
xorl %ecx, %ecx
movzbl %al, %edi
callq 0x11a80
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11af3
movl $0x0, -0x4(%rbp)
jmp 0x11bd8
cmpq $0x0, -0x10(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x11b18
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x11b20
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0x28, %eax
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x11b74
movb -0x19(%rbp), %al
movsbl -0x29(%rbp), %edx
movl $0x95, %ecx
subl %edx, %ecx
movslq %ecx, %rsi
movq -0x28(%rbp), %rdx
movsbl -0x29(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movl %ecx, %edx
movzbl %al, %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x11bd8
movsbl -0x29(%rbp), %eax
addl $0x7, %eax
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x0, %eax
jge 0x11ba1
movq -0x28(%rbp), %rdi
movsbl -0x29(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movslq %eax, %rsi
leaq -0x28(%rbp), %rdx
callq 0x11c20
jmp 0x11bb2
movsbl -0x29(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
movsbl -0x29(%rbp), %edx
movl $0x9c, %ecx
subl %edx, %ecx
movslq %ecx, %rsi
movq -0x28(%rbp), %rcx
movl %ecx, %edx
movq -0x18(%rbp), %rcx
movzbl %al, %edi
callq 0x11cb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11c41
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x11c95
cmpq $0x40, -0x10(%rbp)
jge 0x11c80
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %cl, %rax
movq -0x8(%rbp), %rdx
xorl %ecx, %ecx
subq -0x10(%rbp), %rcx
andq $0x3f, %rcx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x11c93
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x20(%rbp)
jmp 0x11c95
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: int64_to_float64
float64 int64_to_float64(int64_t a, float_status *status)
{
    flag zSign;

    if ( a == 0 ) return float64_zero;
    if ( a == (int64_t) LIT64( 0x8000000000000000 ) ) {
        return packFloat64( 1, 0x43E, 0 );
    }
    zSign = ( a < 0 );
    return normalizeRoundAndPackFloat64(zSign, 0x43C, zSign ? -a : a, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11f11
movq $0x0, -0x8(%rbp)
jmp 0x11f89
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x10(%rbp)
jne 0x11f3a
movl $0x1, %edi
movl $0x43e, %esi            # imm = 0x43E
xorl %eax, %eax
movl %eax, %edx
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x11f89
cmpq $0x0, -0x10(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x1a(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x11f65
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x11f6d
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x1a(%rbp), %al
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x43c, %esi            # imm = 0x43C
movzbl %al, %edi
callq 0x11fa0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: normalizeRoundAndPackFloat64
static float64
 normalizeRoundAndPackFloat64(flag zSign, int_fast16_t zExp, uint64_t zSig,
                              float_status *status)
{
    int8 shiftCount;

    shiftCount = countLeadingZeros64( zSig ) - 1;
    return roundAndPackFloat64(zSign, zExp - shiftCount, zSig<<shiftCount,
                               status);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0x1, %eax
movb %al, -0x21(%rbp)
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rsi
movsbq -0x21(%rbp), %rcx
subq %rcx, %rsi
movq -0x18(%rbp), %rdx
movsbl -0x21(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq -0x20(%rbp), %rcx
movzbl %al, %edi
callq 0x12390
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1202e
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl %esi, %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x1209a
cmpq $0x0, -0x18(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x12053
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1205b
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11bf0
movb %al, -0x31(%rbp)
movb -0x21(%rbp), %al
movsbl -0x31(%rbp), %ecx
movl $0x403e, %esi           # imm = 0x403E
subl %ecx, %esi
movq -0x30(%rbp), %rdx
movsbl -0x31(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movzbl %al, %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movw -0x8(%rbp), %dx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x120e4
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
movl %esi, %edi
movq %rcx, %rdx
callq 0x11a80
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x121aa
cmpq $0x0, -0x18(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x12109
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x12111
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
addl $0x31, %eax
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %ecx
movl $0x406e, %eax           # imm = 0x406E
subl %ecx, %eax
movl %eax, -0x38(%rbp)
movsbl -0x31(%rbp), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x12162
movq $0x0, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movsbl -0x31(%rbp), %eax
subl $0x40, %eax
movb %al, -0x31(%rbp)
jmp 0x12172
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movsbq -0x31(%rbp), %rdx
leaq -0x40(%rbp), %rcx
leaq -0x48(%rbp), %r8
callq 0x121c0
movb -0x21(%rbp), %al
movl -0x38(%rbp), %esi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movzbl %al, %edi
callq 0x11a80
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12263
movl $0x0, -0x4(%rbp)
jmp 0x122f3
movq -0x10(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0x28, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1229e
movl $0x95, %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq %cl, %rax
movl %eax, %edx
xorl %edi, %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x122f3
movl -0x1c(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x122c4
movq -0x10(%rbp), %rdi
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rsi
leaq -0x10(%rbp), %rdx
callq 0x11c20
jmp 0x122d4
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x10(%rbp)
movl $0x9c, %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rcx
xorl %edi, %edi
callq 0x11cb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x43c, -0x1c(%rbp)     # imm = 0x43C
cmpq $0x0, -0x10(%rbp)
jne 0x12328
movq $0x0, -0x8(%rbp)
jmp 0x12383
movq -0x10(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x12357
movq -0x10(%rbp), %rdi
xorl %eax, %eax
subl -0x20(%rbp), %eax
movslq %eax, %rsi
leaq -0x10(%rbp), %rdx
callq 0x11c20
jmp 0x12367
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %edi, %edi
callq 0x12390
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
movb %al, -0x11(%rbp)
movl %esi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1269d
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x18(%rbp), %eax
subl $0x40, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0xf, %eax
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x126dd
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movsbq -0x31(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x121c0
jmp 0x12709
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movsbl -0x31(%rbp), %ecx
xorl %eax, %eax
subl %ecx, %eax
movslq %eax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x20(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0x20420
movsbl -0x31(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movzbl -0x11(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x20590
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11570
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x115f0
movl %eax, -0x2c(%rbp)
movl -0x4(%rbp), %edi
callq 0x115d0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x12810
movb %al, -0x11(%rbp)
cmpq $0xff, -0x20(%rbp)
jne 0x127a4
cmpl $0x0, -0x2c(%rbp)
je 0x127a4
movb $0x0, -0x11(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x127b6
movl -0x2c(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
movl %eax, -0x2c(%rbp)
movl $0xaf, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jge 0x127ef
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x11c20
movb -0x11(%rbp), %al
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movzbl %al, %edi
callq 0x12820
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x115f0
movl %eax, -0x2c(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
callq 0x12810
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
subq $0x9e, %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jg 0x12a1d
cmpl $0xcf000000, -0x8(%rbp) # imm = 0xCF000000
je 0x12a11
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
cmpb $0x0, -0x11(%rbp)
je 0x12a03
cmpq $0xff, -0x20(%rbp)
jne 0x12a0f
cmpl $0x0, -0x2c(%rbp)
je 0x12a0f
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jmp 0x12a9d
jmp 0x12a11
movl $0x80000000, -0x4(%rbp) # imm = 0x80000000
jmp 0x12a9d
cmpq $0x7e, -0x20(%rbp)
jg 0x12a4b
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
orq %rcx, %rax
cmpq $0x0, %rax
je 0x12a42
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x12a9d
jmp 0x12a4d
movl -0x2c(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
shll $0x8, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
xorl %ecx, %ecx
subq -0x28(%rbp), %rcx
shrl %cl, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
andq $0x1f, %rcx
shll %cl, %eax
cmpl $0x0, %eax
je 0x12a89
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
cmpb $0x0, -0x11(%rbp)
je 0x12a97
xorl %eax, %eax
subl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x115f0
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %edi
callq 0x115d0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x12810
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rax
subq $0x8e, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jg 0x12b40
cmpl $0xc7000000, -0xc(%rbp) # imm = 0xC7000000
je 0x12b33
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
cmpb $0x0, -0x19(%rbp)
je 0x12b24
cmpq $0xff, -0x28(%rbp)
jne 0x12b31
cmpl $0x0, -0x34(%rbp)
je 0x12b31
movq $0x7fff, -0x8(%rbp)     # imm = 0x7FFF
jmp 0x12bcf
jmp 0x12b33
movq $-0x8000, -0x8(%rbp)    # imm = 0x8000
jmp 0x12bcf
cmpq $0x7e, -0x28(%rbp)
jg 0x12b6f
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
orq %rcx, %rax
cmpq $0x0, %rax
je 0x12b65
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x12bcf
jmp 0x12b71
movq -0x30(%rbp), %rax
subq $0x10, %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
shll $0x8, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
shrl %cl, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
andq $0x1f, %rcx
shll %cl, %eax
cmpl $0x0, %eax
je 0x12bb9
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
cmpb $0x0, -0x19(%rbp)
je 0x12bc7
xorl %eax, %eax
subl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movslq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x115f0
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %edi
callq 0x115d0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x12810
movb %al, -0x19(%rbp)
movl $0xbe, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x12c78
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
cmpb $0x0, -0x19(%rbp)
je 0x12c58
cmpq $0xff, -0x28(%rbp)
jne 0x12c68
cmpl $0x0, -0x34(%rbp)
je 0x12c68
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0x12cd1
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x8(%rbp)
jmp 0x12cd1
cmpq $0x0, -0x28(%rbp)
je 0x12c8a
movl -0x34(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq $0x28, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rcx
leaq -0x48(%rbp), %r8
callq 0x12ce0
movb -0x19(%rbp), %al
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x18(%rbp), %rcx
movzbl %al, %edi
callq 0x12dc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
xorl %eax, %eax
subq -0x18(%rbp), %rax
andq $0x3f, %rax
movb %al, -0x39(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12d21
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x12da7
cmpq $0x40, -0x18(%rbp)
jge 0x12d5e
movq -0x8(%rbp), %rax
movsbl -0x39(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
cmpq $0x0, -0x10(%rbp)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq %cl, %rax
movq %rax, -0x30(%rbp)
jmp 0x12da5
cmpq $0x40, -0x18(%rbp)
jne 0x12d83
movq -0x8(%rbp), %rax
cmpq $0x0, -0x10(%rbp)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x12d9d
movq -0x8(%rbp), %rax
orq -0x10(%rbp), %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
jmp 0x12da7
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x115f0
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %edi
callq 0x115d0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x12810
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x12fd5
cmpq $0x7e, -0x28(%rbp)
jle 0x12fd5
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl -0xc(%rbp), %edi
callq 0x13070
cmpl $0x0, %eax
je 0x12fc8
movq $-0x1, -0x8(%rbp)
jmp 0x1305a
movq $0x0, -0x8(%rbp)
jmp 0x1305a
movl $0xbe, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12ff4
movl -0x34(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x13013
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq $-0x1, -0x8(%rbp)
jmp 0x1305a
movl -0x34(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq $0x28, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rcx
leaq -0x48(%rbp), %r8
callq 0x12ce0
movb -0x19(%rbp), %al
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x18(%rbp), %rcx
movzbl %al, %edi
callq 0x130a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)