LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb %al, %al
sete -0x2a(%rbp)
movsbl -0x29(%rbp), %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x4, %eax
ja 0x13151
movq -0x38(%rbp), %rax
leaq 0x12799(%rip), %rcx     # 0x25880
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, -0x20(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x2b(%rbp)
jmp 0x13156
movb $0x0, -0x2b(%rbp)
jmp 0x13156
xorl %eax, %eax
cmpb $0x0, -0x9(%rbp)
movb %al, -0x39(%rbp)
jne 0x1311e
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x2b(%rbp)
jmp 0x13156
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0x13144
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x2b(%rbp)
jmp 0x13156
callq 0x1030
cmpb $0x0, -0x2b(%rbp)
je 0x131ad
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13187
movq -0x28(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq $-0x1, -0x8(%rbp)
jmp 0x131f2
movq -0x20(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movzbl -0x2a(%rbp), %ecx
andl %ecx, %eax
xorl $-0x1, %eax
cltq
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
je 0x131d5
cmpq $0x0, -0x18(%rbp)
je 0x131d5
movq -0x28(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq $0x0, -0x8(%rbp)
jmp 0x131f2
cmpq $0x0, -0x20(%rbp)
je 0x131ea
movq -0x28(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movq -0x18(%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_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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x13250
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12f50
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x13250
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %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)
movq -0x28(%rbp), %rax
subq $0xbe, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
jg 0x1331b
cmpl $0xdf000000, -0xc(%rbp) # imm = 0xDF000000
je 0x13308
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
cmpb $0x0, -0x19(%rbp)
je 0x132f3
cmpq $0xff, -0x28(%rbp)
jne 0x13306
cmpl $0x0, -0x34(%rbp)
je 0x13306
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0x133b2
jmp 0x13308
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x8(%rbp)
jmp 0x133b2
cmpq $0x7e, -0x28(%rbp)
jg 0x1334a
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
orq %rcx, %rax
cmpq $0x0, %rax
je 0x13340
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x133b2
jmp 0x1334c
movl -0x34(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shlq $0x28, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
shrq %cl, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0x3f, %rcx
shlq %cl, %rax
cmpq $0x0, %rax
je 0x1339a
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
cmpb $0x0, -0x19(%rbp)
je 0x133aa
xorl %eax, %eax
subq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %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, -0x2c(%rbp)
movl -0xc(%rbp), %edi
callq 0x115d0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x12810
movb %al, -0x19(%rbp)
cmpq $0xff, -0x28(%rbp)
jne 0x13464
cmpl $0x0, -0x2c(%rbp)
je 0x1344c
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x13550
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x134d0
movq %rax, -0x8(%rbp)
jmp 0x134c6
movl $0x7ff, %esi            # imm = 0x7FF
xorl %eax, %eax
movl %eax, %edx
movzbl -0x19(%rbp), %edi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x134c6
cmpq $0x0, -0x28(%rbp)
jne 0x134a3
cmpl $0x0, -0x2c(%rbp)
jne 0x13487
xorl %eax, %eax
movl %eax, %edx
movzbl -0x19(%rbp), %edi
movq %rdx, %rsi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x134c6
movl -0x2c(%rbp), %edi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x135b0
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
movq -0x28(%rbp), %rsi
addq $0x380, %rsi            # imm = 0x380
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
shlq $0x1d, %rdx
movzbl %al, %edi
callq 0x118b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: commonNaNToFloat64
static float64 commonNaNToFloat64(commonNaNT a, float_status *status)
{
    uint64_t mantissa = a.high>>12;

    if (status->default_nan_mode) {
        return float64_default_nan;
    }

    if ( mantissa )
        return make_float64(
              ( ( (uint64_t) a.sign )<<63 )
            | LIT64( 0x7FF0000000000000 )
            | ( a.high>>12 ));
    else
        return float64_default_nan;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq 0x8(%rax), %rax
shrq $0xc, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x13506
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, -0x8(%rbp)
jmp 0x13544
cmpq $0x0, -0x18(%rbp)
je 0x13536
movq -0x20(%rbp), %rcx
movzbl (%rcx), %eax
shlq $0x3f, %rax
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
orq %rdx, %rax
movq 0x8(%rcx), %rcx
shrq $0xc, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x13544
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x111b0
cmpl $0x0, %eax
je 0x13582
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x4(%rbp), %edx
shrl $0x1f, %edx
movb %dl, (%rcx)
movq $0x0, 0x10(%rcx)
movl -0x4(%rbp), %edx
shlq $0x29, %rdx
movq %rdx, 0x8(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x11570
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x115f0
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %edi
callq 0x115d0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x12810
movb %al, -0x21(%rbp)
cmpq $0xff, -0x30(%rbp)
jne 0x136b5
cmpl $0x0, -0x34(%rbp)
je 0x13693
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x13550
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x13730
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x1371f
movl $0x7fff, %esi           # imm = 0x7FFF
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movzbl -0x21(%rbp), %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x1371f
cmpq $0x0, -0x30(%rbp)
jne 0x136eb
cmpl $0x0, -0x34(%rbp)
jne 0x136db
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movzbl -0x21(%rbp), %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x1371f
movl -0x34(%rbp), %edi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x135b0
movl -0x34(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
movl %eax, -0x34(%rbp)
movb -0x21(%rbp), %al
movq -0x30(%rbp), %rcx
addq $0x3f80, %rcx           # imm = 0x3F80
movl %ecx, %esi
movl -0x34(%rbp), %ecx
movl %ecx, %edx
shlq $0x28, %rdx
movzbl %al, %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movw -0x8(%rbp), %dx
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: commonNaNToFloatx80
static floatx80 commonNaNToFloatx80(commonNaNT a, float_status *status)
{
    floatx80 z;

    if (status->default_nan_mode) {
        z.low = floatx80_default_nan_low;
        z.high = floatx80_default_nan_high;
        return z;
    }

    if (a.high >> 1) {
        z.low = LIT64( 0x8000000000000000 ) | a.high >> 1;
        z.high = ( ( (uint16_t) a.sign )<<15 ) | 0x7FFF;
    } else {
        z.low = floatx80_default_nan_low;
        z.high = floatx80_default_nan_high;
    }

    return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x13760
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
movq %rax, -0x10(%rbp)
movw $0xffff, -0x8(%rbp)     # imm = 0xFFFF
jmp 0x137b7
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
shrq %rax
cmpq $0x0, %rax
je 0x137a1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
orq %rdx, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movzwl %ax, %eax
shll $0xf, %eax
orl $0x7fff, %eax           # imm = 0x7FFF
movw %ax, -0x8(%rbp)
jmp 0x137b5
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
movq %rax, -0x10(%rbp)
movw $0xffff, -0x8(%rbp)     # imm = 0xFFFF
jmp 0x137b7
movq -0x10(%rbp), %rax
movw -0x8(%rbp), %dx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x11570
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x115f0
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %edi
callq 0x115d0
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x12810
movb %al, -0x21(%rbp)
cmpq $0xff, -0x30(%rbp)
jne 0x13882
cmpl $0x0, -0x34(%rbp)
je 0x13863
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x13550
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x13900
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x138f2
movl $0x7fff, %esi           # imm = 0x7FFF
xorl %eax, %eax
movl %eax, %ecx
movzbl -0x21(%rbp), %edi
movq %rcx, %rdx
callq 0x11a80
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x138f2
cmpq $0x0, -0x30(%rbp)
jne 0x138c7
cmpl $0x0, -0x34(%rbp)
jne 0x138ab
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
movzbl -0x21(%rbp), %edi
movq %rcx, %rdx
callq 0x11a80
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x138f2
movl -0x34(%rbp), %edi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x135b0
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movb -0x21(%rbp), %al
movq -0x30(%rbp), %rcx
addq $0x3f80, %rcx           # imm = 0x3F80
movl %ecx, %esi
movl -0x34(%rbp), %ecx
movl %ecx, %edx
shlq $0x19, %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 $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: commonNaNToFloat128
static float128 commonNaNToFloat128(commonNaNT a, float_status *status)
{
    float128 z;

    if (status->default_nan_mode) {
        z.low = float128_default_nan_low;
        z.high = float128_default_nan_high;
        return z;
    }

    shift128Right( a.high, a.low, 16, &z.high, &z.low );
    z.high |= ( ( (uint64_t) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );
    return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x13936
movq $0x0, -0x10(%rbp)
movabsq $0x7fff800000000000, %rax # imm = 0x7FFF800000000000
movq %rax, -0x8(%rbp)
jmp 0x13978
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
leaq -0x10(%rbp), %rcx
addq $0x8, %rcx
leaq -0x10(%rbp), %r8
movl $0x10, %edx
callq 0x17be0
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
shlq $0x3f, %rax
movabsq $0x7fff000000000000, %rcx # imm = 0x7FFF000000000000
orq %rcx, %rax
orq -0x8(%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-specialize.h
// Function: propagateFloat32NaN
static float32 propagateFloat32NaN(float32 a, float32 b, float_status *status)
{
    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    flag aIsLargerSignificand;
    uint32_t av, bv;

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

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

    if (status->default_nan_mode)
        return float32_default_nan;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
callq 0x11180
movb %al, -0x19(%rbp)
movl -0x8(%rbp), %edi
callq 0x111b0
movb %al, -0x1a(%rbp)
movl -0xc(%rbp), %edi
callq 0x11180
movb %al, -0x1b(%rbp)
movl -0xc(%rbp), %edi
callq 0x111b0
movb %al, -0x1c(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movzbl -0x1a(%rbp), %eax
movzbl -0x1c(%rbp), %ecx
orl %ecx, %eax
cmpl $0x0, %eax
je 0x13c47
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x18(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x13c5d
movl $0x7fc00000, -0x4(%rbp) # imm = 0x7FC00000
jmp 0x13cdd
movl -0x24(%rbp), %eax
shll %eax
movl -0x28(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jae 0x13c71
movb $0x0, -0x1d(%rbp)
jmp 0x13c9c
movl -0x28(%rbp), %eax
shll %eax
movl -0x24(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jae 0x13c85
movb $0x1, -0x1d(%rbp)
jmp 0x13c9a
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovbl %ecx, %eax
movb %al, -0x1d(%rbp)
jmp 0x13c9c
movb -0x19(%rbp), %sil
movb -0x1a(%rbp), %dl
movb -0x1b(%rbp), %cl
movb -0x1c(%rbp), %al
movzbl %sil, %edi
movzbl %dl, %esi
movzbl %cl, %edx
movzbl %al, %ecx
movzbl -0x1d(%rbp), %r8d
callq 0x24100
cmpl $0x0, %eax
je 0x13cd2
movl -0xc(%rbp), %edi
callq 0x11200
movl %eax, -0x4(%rbp)
jmp 0x13cdd
movl -0x8(%rbp), %edi
callq 0x11200
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_add
float32 float32_add(float32 a, float32 b, float_status *status)
{
    flag aSign, bSign;
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x12810
movb %al, -0x19(%rbp)
movl -0xc(%rbp), %edi
callq 0x12810
movb %al, -0x1a(%rbp)
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x13d5c
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movb -0x19(%rbp), %al
movq -0x18(%rbp), %rcx
movzbl %al, %edx
callq 0x13d80
movl %eax, -0x4(%rbp)
jmp 0x13d74
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movb -0x19(%rbp), %al
movq -0x18(%rbp), %rcx
movzbl %al, %edx
callq 0x14000
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-macros.h
// Function: estimateDiv128To64
static uint64_t estimateDiv128To64( uint64_t a0, uint64_t a1, uint64_t b )
{
    uint64_t b0, b1;
    uint64_t rem0, rem1, term0, term1;
    uint64_t z;

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x14c1b
movq $-0x1, -0x8(%rbp)
jmp 0x14d2e
movq -0x20(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq $0x20, %rax
cmpq -0x10(%rbp), %rax
ja 0x14c45
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, -0x60(%rbp)
jmp 0x14c59
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
shlq $0x20, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x18730
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x18b70
cmpq $0x0, -0x38(%rbp)
jge 0x14cda
movq -0x58(%rbp), %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
subq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x18bd0
jmp 0x14c93
movq -0x38(%rbp), %rax
shlq $0x20, %rax
movq -0x40(%rbp), %rcx
shrq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
shlq $0x20, %rax
cmpq -0x38(%rbp), %rax
ja 0x14d0a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x68(%rbp)
jmp 0x14d1a
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
orq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: estimateSqrt32
static uint32_t estimateSqrt32(int_fast16_t aExp, uint32_t a)
{
    static const uint16_t sqrtOddAdjustments[] = {
        0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
        0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
    };
    static const uint16_t sqrtEvenAdjustments[] = {
        0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
        0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
    };
    int8 index;
    uint32_t z;

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x1b, %eax
andl $0xf, %eax
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x15847
movl -0x14(%rbp), %eax
shrl $0x11, %eax
addl $0x4000, %eax           # imm = 0x4000
movsbl -0x15(%rbp), %ecx
movslq %ecx, %rdx
leaq 0x10272(%rip), %rcx     # 0x25a90
movzwl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl -0x1c(%rbp)
shll $0xe, %eax
movl -0x1c(%rbp), %ecx
shll $0xf, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
jmp 0x158ae
movl -0x14(%rbp), %eax
shrl $0x11, %eax
addl $0x8000, %eax           # imm = 0x8000
movsbl -0x15(%rbp), %ecx
movslq %ecx, %rdx
leaq 0x10250(%rip), %rcx     # 0x25ab0
movzwl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
xorl %edx, %edx
divl -0x1c(%rbp)
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x20000, %eax          # imm = 0x20000
cmpl -0x1c(%rbp), %eax
ja 0x1588b
movl $0xffff8000, %eax       # imm = 0xFFFF8000
movl %eax, -0x20(%rbp)
jmp 0x15894
movl -0x1c(%rbp), %eax
shll $0xf, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0x158ac
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x4(%rbp)
jmp 0x158c7
jmp 0x158ae
movl -0x14(%rbp), %eax
shlq $0x1f, %rax
movl -0x1c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl -0x1c(%rbp), %ecx
shrl %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift32RightJamming
static inline void shift32RightJamming(uint32_t a, int_fast16_t count, uint32_t *zPtr)
{
    uint32_t z;

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x158ee
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x15933
cmpq $0x20, -0x10(%rbp)
jge 0x15922
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
shrl %cl, %eax
movl -0x4(%rbp), %edx
xorl %ecx, %ecx
subq -0x10(%rbp), %rcx
andq $0x1f, %rcx
shll %cl, %edx
movl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15931
cmpl $0x0, -0x4(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15933
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_exp2
float32 float32_exp2(float32 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;
    float64 r, x, xn;
    int i;
    a = float32_squash_input_denormal(a, status);

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

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

    float_raise(float_flag_inexact, status);

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

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

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

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

    return float64_to_float32(r, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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, -0x24(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
callq 0x12810
movb %al, -0x11(%rbp)
cmpq $0xff, -0x20(%rbp)
jne 0x159c7
cmpl $0x0, -0x24(%rbp)
je 0x159a6
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x13be0
movl %eax, -0x4(%rbp)
jmp 0x15aa3
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0x159b6
xorl %eax, %eax
movl %eax, -0x54(%rbp)
jmp 0x159bc
movl -0x8(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15aa3
cmpq $0x0, -0x20(%rbp)
jne 0x159e2
cmpl $0x0, -0x24(%rbp)
jne 0x159e0
movl $0x3f800000, -0x4(%rbp) # imm = 0x3F800000
jmp 0x15aa3
jmp 0x159e2
movq -0x10(%rbp), %rsi
movl $0x20, %edi
callq 0x11080
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x133c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
movabsq $0x3fe62e42fefa39ef, %rsi # imm = 0x3FE62E42FEFA39EF
callq 0x15ab0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x30(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0xf, -0x44(%rbp)
jge 0x15a93
movq -0x40(%rbp), %rdi
movslq -0x44(%rbp), %rcx
leaq 0xffc3(%rip), %rax      # 0x25a10
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rdx
callq 0x15ab0
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x15d60
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x15ab0
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x15a38
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15e00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_add
float64 float64_add(float64 a, float64 b, float_status *status)
{
    flag aSign, bSign;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11610
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11610
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x168f0
movb %al, -0x22(%rbp)
movzbl -0x21(%rbp), %eax
movzbl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jne 0x15dd7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x21(%rbp), %al
movq -0x20(%rbp), %rcx
movzbl %al, %edx
callq 0x180f0
movq %rax, -0x8(%rbp)
jmp 0x15df2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x21(%rbp), %al
movq -0x20(%rbp), %rcx
movzbl %al, %edx
callq 0x183c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_float32
float32 float64_to_float32(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig;
    uint32_t zSig;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp == 0x7FF ) {
        if (aSig) {
            return commonNaNToFloat32(float64ToCommonNaN(a, status), status);
        }
        return packFloat32( aSign, 0xFF, 0 );
    }
    shift64RightJamming( aSig, 22, &aSig );
    zSig = aSig;
    if ( aExp || zSig ) {
        zSig |= 0x40000000;
        aExp -= 0x381;
    }
    return roundAndPackFloat32(aSign, aExp, zSig, status);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11610
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x116a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11680
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x19(%rbp)
cmpq $0x7ff, -0x28(%rbp)     # imm = 0x7FF
jne 0x15ea9
cmpq $0x0, -0x30(%rbp)
je 0x15e94
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x16f00
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x16e90
movl %eax, -0x4(%rbp)
jmp 0x15f01
movl $0xff, %esi
xorl %edx, %edx
movzbl -0x19(%rbp), %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x15f01
movq -0x30(%rbp), %rdi
movl $0x16, %esi
leaq -0x30(%rbp), %rdx
callq 0x11c20
movq -0x30(%rbp), %rax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x15ecf
cmpl $0x0, -0x34(%rbp)
je 0x15ee8
movl -0x34(%rbp), %eax
orl $0x40000000, %eax       # imm = 0x40000000
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
subq $0x381, %rax            # imm = 0x381
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
movq -0x28(%rbp), %rsi
movl -0x34(%rbp), %edx
movq -0x18(%rbp), %rcx
movzbl %al, %edi
callq 0x11cb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_eq
int float32_eq(float32 a, float32 b, float_status *status)
{
    uint32_t av, bv;
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x160dd
movl -0x8(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
jne 0x160fa
movl -0xc(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x16111
movl -0xc(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
je 0x16111
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x16146
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
movb $0x1, %al
cmpl -0x20(%rbp), %ecx
movb %al, -0x21(%rbp)
je 0x1613b
movl -0x1c(%rbp), %eax
orl -0x20(%rbp), %eax
shll %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_le
int float32_le(float32 a, float32 b, float_status *status)
{
    flag aSign, bSign;
    uint32_t av, bv;
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x1619d
movl -0x8(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
jne 0x161ba
movl -0xc(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x161d4
movl -0xc(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
je 0x161d4
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x16264
movl -0x8(%rbp), %edi
callq 0x12810
movb %al, -0x19(%rbp)
movl -0xc(%rbp), %edi
callq 0x12810
movb %al, -0x1a(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movzbl -0x19(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
je 0x1622e
movzbl -0x19(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
jne 0x16221
movl -0x20(%rbp), %eax
orl -0x24(%rbp), %eax
shll %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x16264
movl -0x20(%rbp), %ecx
movb $0x1, %al
cmpl -0x24(%rbp), %ecx
movb %al, -0x26(%rbp)
je 0x16259
movzbl -0x19(%rbp), %eax
movl -0x20(%rbp), %ecx
cmpl -0x24(%rbp), %ecx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_unordered
int float32_unordered(float32 a, float32 b, float_status *status)
{
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x163dd
movl -0x8(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
jne 0x163fa
movl -0xc(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x16411
movl -0xc(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
je 0x16411
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x1, -0x4(%rbp)
jmp 0x16418
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_eq_quiet
int float32_eq_quiet(float32 a, float32 b, float_status *status)
{
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 0;
    }
    return ( float32_val(a) == float32_val(b) ) ||
            ( (uint32_t) ( ( float32_val(a) | float32_val(b) )<<1 ) == 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x1647d
movl -0x8(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
jne 0x1649a
movl -0xc(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x164cb
movl -0xc(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
je 0x164cb
movl -0x8(%rbp), %edi
callq 0x111b0
cmpl $0x0, %eax
jne 0x164b4
movl -0xc(%rbp), %edi
callq 0x111b0
cmpl $0x0, %eax
je 0x164c2
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x164f4
movl -0x8(%rbp), %ecx
movb $0x1, %al
cmpl -0xc(%rbp), %ecx
movb %al, -0x19(%rbp)
je 0x164e9
movl -0x8(%rbp), %eax
orl -0xc(%rbp), %eax
shll %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
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: float32_unordered_quiet
int float32_unordered_quiet(float32 a, float32 b, float_status *status)
{
    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);

    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
       ) {
        if ( float32_is_signaling_nan( a ) || float32_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x167cd
movl -0x8(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
jne 0x167ea
movl -0xc(%rbp), %edi
callq 0x115d0
cmpq $0xff, %rax
jne 0x1681b
movl -0xc(%rbp), %edi
callq 0x115f0
cmpl $0x0, %eax
je 0x1681b
movl -0x8(%rbp), %edi
callq 0x111b0
cmpl $0x0, %eax
jne 0x16804
movl -0xc(%rbp), %edi
callq 0x111b0
cmpl $0x0, %eax
je 0x16812
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x1, -0x4(%rbp)
jmp 0x16822
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int32
int32 float64_to_int32(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig;
    a = float64_squash_input_denormal(a, status);

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11610
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x116a0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11680
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x168f0
movb %al, -0x11(%rbp)
cmpq $0x7ff, -0x20(%rbp)     # imm = 0x7FF
jne 0x1688c
cmpq $0x0, -0x30(%rbp)
je 0x1688c
movb $0x0, -0x11(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x168a5
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x42c, %eax            # imm = 0x42C
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jge 0x168cb
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11c20
movb -0x11(%rbp), %al
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movzbl %al, %edi
callq 0x12820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)