LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: special_sf32
F_UINT special_sf(int i)
{
    switch(i) {
    case 0: /* zero */
    case 1:
        return pack_sf(i & 1, 0, 0);
    case 2: /* infinity */
    case 3:
        return pack_sf(i & 1, EXP_MASK, 0);
    case 4: /* 1.0 */
    case 5:
        return pack_sf(i & 1, EXP_MASK / 2, 0);
    case 6: /* QNAN */
    case 7:
        return pack_sf(i & 1, EXP_MASK, QNAN_MASK);
    case 8: /* SNAN */
    case 9:
        return pack_sf(i & 1, EXP_MASK, 1);
    case 10: /* subnormal */
    case 11:
        return pack_sf(i & 1, 0, 1);
    default:
        abort();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0xb, %rax
ja 0x13fd
movq -0x10(%rbp), %rax
leaq 0x23ca9(%rip), %rcx     # 0x25010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x8(%rbp), %edi
andl $0x1, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x1310
movl %eax, -0x4(%rbp)
jmp 0x1402
movl -0x8(%rbp), %edi
andl $0x1, %edi
movl $0xff, %esi
xorl %edx, %edx
callq 0x1310
movl %eax, -0x4(%rbp)
jmp 0x1402
movl -0x8(%rbp), %edi
andl $0x1, %edi
movl $0x7f, %esi
xorl %edx, %edx
callq 0x1310
movl %eax, -0x4(%rbp)
jmp 0x1402
movl -0x8(%rbp), %edi
andl $0x1, %edi
movl $0xff, %esi
movl $0x400000, %edx         # imm = 0x400000
callq 0x1310
movl %eax, -0x4(%rbp)
jmp 0x1402
movl -0x8(%rbp), %edi
andl $0x1, %edi
movl $0xff, %esi
movl $0x1, %edx
callq 0x1310
movl %eax, -0x4(%rbp)
jmp 0x1402
movl -0x8(%rbp), %edi
andl $0x1, %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1310
movl %eax, -0x4(%rbp)
jmp 0x1402
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: exec_ref_op32
F_UINT exec_ref_op(uint32_t *pfflags, FloatOpEnum op,
                   F_UINT a, F_UINT b, RoundingModeEnum rm)
{
    F_UINT r;
    float_status st;
    softfloat_float a1, b1, r1;

    softfloat_init_ctx(&st, rm);
    a1 = sf_to_softfloat(a);
    b1 = sf_to_softfloat(b);

    switch(op) {
    case OP_FADD:
        r1 = glue(glue(float, F_SIZE), _add)(a1, b1, &st);
        break;
    case OP_FMUL:
        r1 = glue(glue(float, F_SIZE), _mul)(a1, b1, &st);
        break;
    case OP_FDIV:
        r1 = glue(glue(float, F_SIZE), _div)(a1, b1, &st);
        break;
    case OP_FSQRT:
        r1 = glue(glue(float, F_SIZE), _sqrt)(a1, &st);
        break;
#if F_SIZE <= 64
    case OP_FMIN:
        r1 = glue(glue(float, F_SIZE), _minnum)(a1, b1, &st);
        break;
    case OP_FMAX:
        r1 = glue(glue(float, F_SIZE), _maxnum)(a1, b1, &st);
        break;
#endif
    default:
        abort();
    }
    r = softfloat_to_sf(r1);
    *pfflags = softfloat_to_fflags(&st);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x18(%rbp), %esi
leaq -0x23(%rbp), %rdi
callq 0x1510
movl -0x10(%rbp), %edi
callq 0x1560
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x1560
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0x14e5
movq -0x38(%rbp), %rax
leaq 0x23bd9(%rip), %rcx     # 0x25040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x28(%rbp), %edi
movl -0x2c(%rbp), %esi
leaq -0x23(%rbp), %rdx
callq 0x13cf0
movl %eax, -0x30(%rbp)
jmp 0x14ea
movl -0x28(%rbp), %edi
movl -0x2c(%rbp), %esi
leaq -0x23(%rbp), %rdx
callq 0x14300
movl %eax, -0x30(%rbp)
jmp 0x14ea
movl -0x28(%rbp), %edi
movl -0x2c(%rbp), %esi
leaq -0x23(%rbp), %rdx
callq 0x14560
movl %eax, -0x30(%rbp)
jmp 0x14ea
movl -0x28(%rbp), %edi
leaq -0x23(%rbp), %rsi
callq 0x15600
movl %eax, -0x30(%rbp)
jmp 0x14ea
movl -0x28(%rbp), %edi
movl -0x2c(%rbp), %esi
leaq -0x23(%rbp), %rdx
callq 0x23740
movl %eax, -0x30(%rbp)
jmp 0x14ea
movl -0x28(%rbp), %edi
movl -0x2c(%rbp), %esi
leaq -0x23(%rbp), %rdx
callq 0x23780
movl %eax, -0x30(%rbp)
jmp 0x14ea
callq 0x1030
movl -0x30(%rbp), %edi
callq 0x1570
movl %eax, -0x1c(%rbp)
leaq -0x23(%rbp), %rdi
callq 0x1580
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfptest.c
// Function: softfloat_to_fflags
static uint32_t softfloat_to_fflags(float_status *st)
{
    uint32_t fflags;
    fflags = 0;
    if (st->float_exception_flags & float_flag_invalid)
        fflags |= FFLAG_INVALID_OP;
    if (st->float_exception_flags & float_flag_divbyzero)
        fflags |= FFLAG_DIVIDE_ZERO;
    if (st->float_exception_flags & float_flag_overflow)
        fflags |= FFLAG_OVERFLOW;
    if (st->float_exception_flags & float_flag_underflow)
        fflags |= FFLAG_UNDERFLOW;
    if (st->float_exception_flags & float_flag_inexact)
        fflags |= FFLAG_INEXACT;
    return fflags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15a8
movl -0xc(%rbp), %eax
orl $0x10, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x15c1
movl -0xc(%rbp), %eax
orl $0x8, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x15da
movl -0xc(%rbp), %eax
orl $0x4, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x15f3
movl -0xc(%rbp), %eax
orl $0x2, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x160c
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: print_sf128
static void print_sf(F_UINT a)
{
    uint32_t a_sign, a_exp;
    F_UINT a_mant;
    a_sign = a >> (F_SIZE - 1);
    a_exp = (a >> MANT_SIZE) & EXP_MASK;
    a_mant = a & MANT_MASK;
    printf("%u %0*x ",
           a_sign,
           (EXP_SIZE + 3) / 4, a_exp);
#if F_SIZE == 32
    printf("%0*x", (MANT_SIZE + 3) / 4, a_mant);
#elif F_SIZE == 64
    printf("%0*" PRIx64 , (MANT_SIZE + 3) / 4, a_mant);
#elif F_SIZE == 128
    printf("%0*" PRIx64 "%016" PRIx64, 
           ((MANT_SIZE - 64) + 3) / 4, (uint64_t)(a_mant >> 64), (uint64_t)a_mant);
#else
#error unsupported F_SIZE
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3f, %rax
movl %eax, -0x24(%rbp)
movzwl -0x12(%rbp), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
andq %rdx, %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %ecx
leaq 0x20535(%rip), %rdi     # 0x254a6
xorl %eax, %eax
movl $0x4, %edx
callq 0x1050
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
leaq 0x2053b(%rip), %rdi     # 0x254c7
movl $0xc, %esi
movb $0x0, %al
callq 0x1050
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: test_op_all64
void test_op_all(F_UINT a, F_UINT b, RoundingModeEnum rm, int it)
{
    test_op(OP_FADD, a, b, rm, it);
    test_op(OP_FMUL, a, b, rm, it);
    test_op(OP_FDIV, a, b, rm, it);
    test_op(OP_FSQRT, a, b, rm, it);
#if F_SIZE <= 64
    test_op(OP_FMIN, a, b, rm, it);
#endif
#if F_SIZE <= 64
    test_op(OP_FMAX, a, b, rm, it);
#endif
    test_cmp(a, b, it);

#if F_SIZE >= 64
    test_cvt_sf32_sf(a, rm, it);
#endif
#if F_SIZE >= 128
    test_cvt_sf64_sf(a, rm, it);
#endif
    test_cvt_int_sf(a, rm, it);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
xorl %edi, %edi
callq 0x2da0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x1, %edi
callq 0x2da0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x2, %edi
callq 0x2da0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x3, %edi
callq 0x2da0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x4, %edi
callq 0x2da0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x5, %edi
callq 0x2da0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x3e20
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3010
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3220
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: test_float32
void test_float(int step)
{
    F_UINT a, b, c;
    int rm_count, i, j, k;
    RoundingModeEnum rm;

#ifdef USE_REF_X86
    rm_count = 4;
#else
    rm_count = 5;
#endif
    if (step == 0) {
        /* test all simple cases */
        for(i = 0; i < SPECIAL_COUNT; i++) {
            a = special_sf(i);
            for(j = 0; j < SPECIAL_COUNT; j++) {
                b = special_sf(j);
                for(rm = 0; rm < rm_count; rm++) {
                    test_op_all(a, b, rm, i * SPECIAL_COUNT + j);
                    for(k = 0; k < SPECIAL_COUNT; k++) {
                        c = special_sf(k);
                        test_fma(a, b, c, rm, (i * SPECIAL_COUNT + j) * SPECIAL_COUNT + k);
                    }
                }
            }
        }
    } else {
        for(i = 0; i < 1000; i++) {
            /* Note: we cannot test RM_RMM */
            a = rrandom_sf();
            b = rrandom_sf();
            c = rrandom_sf();
            for(rm = 0; rm < rm_count; rm++) {
                test_op_all(a, b, rm, i);
                test_fma(a, b, c, rm, i);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0x5, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x2a1a
movl $0x0, -0x18(%rbp)
cmpl $0xc, -0x18(%rbp)
jge 0x2a18
movl -0x18(%rbp), %edi
callq 0x1340
movl %eax, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xc, -0x1c(%rbp)
jge 0x2a08
movl -0x1c(%rbp), %edi
callq 0x1340
movl %eax, -0xc(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x29f8
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
imull $0xc, -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
callq 0x2870
movl $0x0, -0x20(%rbp)
cmpl $0xc, -0x20(%rbp)
jge 0x29eb
movl -0x20(%rbp), %edi
callq 0x1340
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x24(%rbp), %ecx
imull $0xc, -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
imull $0xc, %eax, %r8d
addl -0x20(%rbp), %r8d
callq 0x24b0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x29af
jmp 0x29ed
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x298b
jmp 0x29fa
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x296f
jmp 0x2a0a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2953
jmp 0x2a91
movl $0x0, -0x18(%rbp)
cmpl $0x3e8, -0x18(%rbp)     # imm = 0x3E8
jge 0x2a8f
callq 0x1270
movl %eax, -0x8(%rbp)
callq 0x1270
movl %eax, -0xc(%rbp)
callq 0x1270
movl %eax, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x2a82
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x2870
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x18(%rbp), %r8d
callq 0x24b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2a49
jmp 0x2a84
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2a21
jmp 0x2a91
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfptest.c
// Function: main
int main(int argc, char **argv)
{
    int seed;

    seed = 1;
    if (argc >= 2)
        seed = atoi(argv[1]);
    srandom(seed);

    printf("Starting softfptest (stop with Ctrl-C)\n");
    test_float32(0);
    test_float64(0);
#ifdef HAVE_INT128
    test_float128(0);
#endif
    for(;;) {
        test_float32(1);
        test_float64(1);
#ifdef HAVE_INT128
        test_float128(1);
#endif
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x2, -0x8(%rbp)
jl 0x6bb3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1090
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1040
leaq 0x1e889(%rip), %rdi     # 0x2544b
movb $0x0, %al
callq 0x1050
xorl %edi, %edi
callq 0x2930
xorl %edi, %edi
callq 0x4140
xorl %edi, %edi
callq 0x67b0
movl $0x1, %edi
callq 0x2930
movl $0x1, %edi
callq 0x4140
movl $0x1, %edi
callq 0x67b0
jmp 0x6bde
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: issignan_sf32
BOOL issignan_sf(F_UINT a)
{
    uint32_t a_exp1;
    F_UINT a_mant;
    a_exp1 = (a >> (MANT_SIZE - 1)) & ((1 << (EXP_SIZE + 1)) - 1);
    a_mant = a & MANT_MASK;
    return (a_exp1 == (2 * EXP_MASK) && a_mant != 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x16, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x1fe, -0x8(%rbp)      # imm = 0x1FE
movb %al, -0xd(%rbp)
jne 0x6c38
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%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/./softfp_template.h
// Function: isnan_sf32
BOOL isnan_sf(F_UINT a)
{
    uint32_t a_exp;
    F_UINT a_mant;
    a_exp = (a >> MANT_SIZE) & EXP_MASK;
    a_mant = a & MANT_MASK;
    return (a_exp == EXP_MASK && a_mant != 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x17, %eax
andl $0xff, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0xff, -0x8(%rbp)
movb %al, -0xd(%rbp)
jne 0x6c88
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%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/./softfp_template.h
// Function: rshift_rnd32
static F_UINT rshift_rnd(F_UINT a, int d)
{
    F_UINT mask;
    if (d != 0) {
        if (d >= F_SIZE) {
            a = (a != 0);
        } else {
            mask = ((F_UINT)1 << d) - 1;
            a = (a >> d) | ((a & mask) != 0);
        }
    }
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x6ea8
cmpl $0x20, -0x8(%rbp)
jl 0x6e77
cmpl $0x0, -0x4(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x6ea6
movl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
shrl %cl, %eax
movl -0x4(%rbp), %ecx
andl -0xc(%rbp), %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6ea8
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: normalize_sf32
static F_UINT normalize_sf(uint32_t a_sign, int a_exp, F_UINT a_mant,
                           RoundingModeEnum rm, uint32_t *pfflags)
{
    int shift;
    shift = clz(a_mant) - (F_SIZE - 1 - IMANT_SIZE);
    assert(shift >= 0);
    a_exp -= shift;
    a_mant <<= shift;
    return round_pack_sf(a_sign, a_exp, a_mant, rm, pfflags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x109d0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x6ede
jmp 0x6efd
leaq 0x1e6df(%rip), %rdi     # 0x255c4
leaq 0x1e6e3(%rip), %rsi     # 0x255cf
movl $0xb7, %edx
leaq 0x1e6eb(%rip), %rcx     # 0x255e3
callq 0x1060
movl -0x1c(%rbp), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x1c(%rbp), %ecx
movl -0xc(%rbp), %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %r8
callq 0x10a00
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: normalize2_sf32
static F_UINT normalize2_sf(uint32_t a_sign, int a_exp, F_UINT a_mant1, F_UINT a_mant0,
                            RoundingModeEnum rm, uint32_t *pfflags)
{
    int l, shift;
    if (a_mant1 == 0) {
        l = F_SIZE + clz(a_mant0);
    } else {
        l = clz(a_mant1);
    }
    shift = l - (F_SIZE - 1 - IMANT_SIZE);
    assert(shift >= 0);
    a_exp -= shift;
    if (shift == 0) {
        a_mant1 |= (a_mant0 != 0);
    } else if (shift < F_SIZE) {
        a_mant1 = (a_mant1 << shift) | (a_mant0 >> (F_SIZE - shift));
        a_mant0 <<= shift;
        a_mant1 |= (a_mant0 != 0);
    } else {
        a_mant1 = a_mant0 << (shift - F_SIZE);
    }
    return round_pack_sf(a_sign, a_exp, a_mant1, rm, pfflags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movq %r9, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x7722
movl -0x10(%rbp), %edi
callq 0x109d0
addl $0x20, %eax
movl %eax, -0x24(%rbp)
jmp 0x772d
movl -0xc(%rbp), %edi
callq 0x109d0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x773e
jmp 0x775d
leaq 0x1de7f(%rip), %rdi     # 0x255c4
leaq 0x1de83(%rip), %rsi     # 0x255cf
movl $0xc9, %edx
leaq 0x1deda(%rip), %rcx     # 0x25632
callq 0x1060
movl -0x28(%rbp), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x7782
cmpl $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x77d3
cmpl $0x20, -0x28(%rbp)
jge 0x77c3
movl -0xc(%rbp), %eax
movl -0x28(%rbp), %ecx
shll %cl, %eax
movl -0x10(%rbp), %edx
movl $0x20, %ecx
subl -0x28(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x28(%rbp), %ecx
movl -0x10(%rbp), %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x77d1
movl -0x10(%rbp), %eax
movl -0x28(%rbp), %ecx
subl $0x20, %ecx
shll %cl, %eax
movl %eax, -0xc(%rbp)
jmp 0x77d3
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0x10a00
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: sqrtrem_u32
static int sqrtrem_u(F_UINT *pr, F_UINT ah, F_UINT al)
{
    F_ULONG a, u, s;
    int l, inexact;

    /* 2^l >= a */
    if (ah != 0) {
        l = 2 * F_SIZE - clz(ah - 1);
    } else {
        if (al == 0) {
            *pr = 0;
            return 0;
        }
        l = F_SIZE - clz(al - 1);
    }
    a = ((F_ULONG)ah << F_SIZE) | al;
    u = (F_ULONG)1 << ((l + 1) / 2);
    for(;;) {
        s = u;
        u = ((a / s) + s) / 2;
        if (u >= s)
            break;
    }
    inexact = (a - s * s) != 0;
    *pr = s;
    return inexact;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x7c21
movl -0x14(%rbp), %edi
subl $0x1, %edi
callq 0x109d0
movl %eax, %ecx
movl $0x40, %eax
subl %ecx, %eax
movl %eax, -0x34(%rbp)
jmp 0x7c54
cmpl $0x0, -0x18(%rbp)
jne 0x7c3d
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7ce1
movl -0x18(%rbp), %edi
subl $0x1, %edi
callq 0x109d0
movl %eax, %ecx
movl $0x20, %eax
subl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
shlq $0x20, %rax
movl -0x18(%rbp), %ecx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x30(%rbp)
addq -0x30(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x7cae
jmp 0x7cb0
jmp 0x7c83
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
imulq -0x30(%rbp), %rcx
subq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: min_sf32
F_UINT glue(min_sf, F_SIZE)(F_UINT a, F_UINT b, uint32_t *pfflags)
{
    uint32_t a_sign, b_sign;

    if (isnan_sf(a) || isnan_sf(b)) {
        if (issignan_sf(a) || issignan_sf(b)) {
            *pfflags |= FFLAG_INVALID_OP;
            return F_QNAN;
        } else if (isnan_sf(a)) {
            if (isnan_sf(b)) 
                return F_QNAN;
            else
                return b;
        } else {
            return a;
        }
    }
    a_sign = a >> (F_SIZE - 1);
    b_sign = b >> (F_SIZE - 1);

    if (a_sign != b_sign) {
        if (a_sign)
            return a;
        else
            return b;
    } else {
        if ((a < b) ^ a_sign)
            return a;
        else
            return b;
    }
}

// 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
callq 0x6c50
cmpl $0x0, %eax
jne 0x7d1c
movl -0xc(%rbp), %edi
callq 0x6c50
cmpl $0x0, %eax
je 0x7d80
movl -0x8(%rbp), %edi
callq 0x6c00
cmpl $0x0, %eax
jne 0x7d36
movl -0xc(%rbp), %edi
callq 0x6c00
cmpl $0x0, %eax
je 0x7d4d
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movl $0x7fc00000, -0x4(%rbp) # imm = 0x7FC00000
jmp 0x7dd4
movl -0x8(%rbp), %edi
callq 0x6c50
cmpl $0x0, %eax
je 0x7d78
movl -0xc(%rbp), %edi
callq 0x6c50
cmpl $0x0, %eax
je 0x7d70
movl $0x7fc00000, -0x4(%rbp) # imm = 0x7FC00000
jmp 0x7dd4
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7dd4
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7dd4
movl -0x8(%rbp), %eax
shrl $0x1f, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1f, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x7db0
cmpl $0x0, -0x1c(%rbp)
je 0x7da8
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7dd4
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7dd4
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
xorl -0x1c(%rbp), %eax
cmpl $0x0, %eax
je 0x7dce
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7dd4
movl -0xc(%rbp), %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/./softfp_template.h
// Function: eq_quiet_sf32
int glue(eq_quiet_sf, F_SIZE)(F_UINT a, F_UINT b, uint32_t *pfflags)
{
    if (isnan_sf(a) || isnan_sf(b)) {
        if (issignan_sf(a) || issignan_sf(b)) {
            *pfflags |= FFLAG_INVALID_OP;
        }
        return 0;
    }

    if ((F_UINT)((a | b) << 1) == 0)
        return 1; /* zero case */
    return (a == b);
}

// 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
callq 0x6c50
cmpl $0x0, %eax
jne 0x7efc
movl -0xc(%rbp), %edi
callq 0x6c50
cmpl $0x0, %eax
je 0x7f2a
movl -0x8(%rbp), %edi
callq 0x6c00
cmpl $0x0, %eax
jne 0x7f16
movl -0xc(%rbp), %edi
callq 0x6c00
cmpl $0x0, %eax
je 0x7f21
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7f51
movl -0x8(%rbp), %eax
orl -0xc(%rbp), %eax
shll %eax
cmpl $0x0, %eax
jne 0x7f40
movl $0x1, -0x4(%rbp)
jmp 0x7f51
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: le_sf32
int glue(le_sf, F_SIZE)(F_UINT a, F_UINT b, uint32_t *pfflags)
{
    uint32_t a_sign, b_sign;

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

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

// Assembly:
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 0x6c50
cmpl $0x0, %eax
jne 0x7f8c
movl -0xc(%rbp), %edi
callq 0x6c50
cmpl $0x0, %eax
je 0x7fa0
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x800d
movl -0x8(%rbp), %eax
shrl $0x1f, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1f, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x7fe3
movb $0x1, %al
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jne 0x7fd6
movl -0x8(%rbp), %eax
orl -0xc(%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)
jmp 0x800d
cmpl $0x0, -0x1c(%rbp)
je 0x7ffc
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x800d
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
setbe %al
andb $0x1, %al
movzbl %al, %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/./softfp_template.h
// Function: fclass_sf32
uint32_t glue(fclass_sf, F_SIZE)(F_UINT a)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;
    uint32_t ret;

    a_sign = a >> (F_SIZE - 1);
    a_exp = (a >> MANT_SIZE) & EXP_MASK;
    a_mant = a & MANT_MASK;
    if (a_exp == EXP_MASK) {
        if (a_mant != 0) {
            if (a_mant & QNAN_MASK)
                ret = FCLASS_QNAN;
            else
                ret = FCLASS_SNAN;
        } else {
            if (a_sign)
                ret = FCLASS_NINF;
            else
                ret = FCLASS_PINF;
        }
    } else if (a_exp == 0) {
        if (a_mant == 0) {
            if (a_sign)
                ret = FCLASS_NZERO;
            else
                ret = FCLASS_PZERO;
        } else {
            if (a_sign)
                ret = FCLASS_NSUBNORMAL;
            else
                ret = FCLASS_PSUBNORMAL;
        }
    } else {
        if (a_sign)
            ret = FCLASS_NNORMAL;
        else
            ret = FCLASS_PNORMAL;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x1f, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl $0x17, %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
movl %eax, -0x10(%rbp)
cmpl $0xff, -0xc(%rbp)
jne 0x8151
cmpl $0x0, -0x10(%rbp)
je 0x8137
movl -0x10(%rbp), %eax
andl $0x400000, %eax         # imm = 0x400000
cmpl $0x0, %eax
je 0x812e
movl $0x200, -0x14(%rbp)     # imm = 0x200
jmp 0x8135
movl $0x100, -0x14(%rbp)     # imm = 0x100
jmp 0x814f
cmpl $0x0, -0x8(%rbp)
je 0x8146
movl $0x1, -0x14(%rbp)
jmp 0x814d
movl $0x80, -0x14(%rbp)
jmp 0x814f
jmp 0x81a9
cmpl $0x0, -0xc(%rbp)
jne 0x818f
cmpl $0x0, -0x10(%rbp)
jne 0x8175
cmpl $0x0, -0x8(%rbp)
je 0x816c
movl $0x8, -0x14(%rbp)
jmp 0x8173
movl $0x10, -0x14(%rbp)
jmp 0x818d
cmpl $0x0, -0x8(%rbp)
je 0x8184
movl $0x4, -0x14(%rbp)
jmp 0x818b
movl $0x20, -0x14(%rbp)
jmp 0x818d
jmp 0x81a7
cmpl $0x0, -0x8(%rbp)
je 0x819e
movl $0x2, -0x14(%rbp)
jmp 0x81a5
movl $0x40, -0x14(%rbp)
jmp 0x81a7
jmp 0x81a9
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template_icvt.h
// Function: internal_cvt_i32_sf32
static F_UINT glue(glue(glue(internal_cvt_i, ICVT_SIZE), _sf), F_SIZE)(ICVT_INT a, 
                                                                       RoundingModeEnum rm,
                                                                       uint32_t *pfflags,
                                                                       BOOL is_unsigned)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;
    ICVT_UINT r, mask;
    int l;

    if (!is_unsigned && a < 0) {
        a_sign = 1;
        r = -(ICVT_UINT)a;
    } else {
        a_sign = 0;
        r = a;
    }
    a_exp = (EXP_MASK / 2) + F_SIZE - 2;
    /* need to reduce range before generic float normalization */
    l = ICVT_SIZE - glue(clz, ICVT_SIZE)(r) - (F_SIZE - 1);
    if (l > 0) {
        mask = r & (((ICVT_UINT)1 << l) - 1);
        r = (r >> l) | ((r & mask) != 0);
        a_exp += l;
    }
    a_mant = r;
    return normalize_sf(a_sign, a_exp, a_mant, rm, pfflags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x8432
cmpl $0x0, -0x4(%rbp)
jge 0x8432
movl $0x1, -0x18(%rbp)
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x843f
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x9d, -0x1c(%rbp)
movl -0x24(%rbp), %edi
callq 0x109d0
movl %eax, %ecx
movl $0x20, %eax
subl %ecx, %eax
subl $0x1f, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x84a2
movl -0x24(%rbp), %eax
movl -0x2c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x2c(%rbp), %ecx
shrl %cl, %eax
movl -0x24(%rbp), %ecx
andl -0x28(%rbp), %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %r8
callq 0x6eb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: cvt_sf32_sf64
F_UINT cvt_sf32_sf(uint32_t a, uint32_t *pfflags)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;

    a_mant = unpack_sf32(&a_sign, &a_exp, a);
    if (a_exp == 0xff) {
        if (a_mant != 0) {
            /* NaN */
            if (issignan_sf32(a)) {
                *pfflags |= FFLAG_INVALID_OP;
            }
            return F_QNAN;
        } else {
            /* infinity */
            return pack_sf(a_sign, EXP_MASK, 0);
        }
    }
    if (a_exp == 0) {
        if (a_mant == 0)
            return pack_sf(a_sign, 0, 0); /* zero */
        a_mant = normalize_subnormal_sf32(&a_exp, a_mant);
    }
    /* convert the exponent value */
    a_exp = a_exp - 0x7f + (EXP_MASK / 2);
    /* shift the mantissa */
    a_mant <<= (MANT_SIZE - 23);
    /* We assume the target float is large enough to that no
       normalization is necessary */
    return pack_sf(a_sign, a_exp, a_mant);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %edx
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa940
movl %eax, %eax
movq %rax, -0x28(%rbp)
cmpl $0xff, -0x20(%rbp)
jne 0xa8c4
cmpq $0x0, -0x28(%rbp)
je 0xa8ad
movl -0xc(%rbp), %edi
callq 0x6c00
cmpl $0x0, %eax
je 0xa89d
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, -0x8(%rbp)
jmp 0xa927
movl -0x1c(%rbp), %edi
movl $0x7ff, %esi            # imm = 0x7FF
xorl %eax, %eax
movl %eax, %edx
callq 0x9420
movq %rax, -0x8(%rbp)
jmp 0xa927
cmpl $0x0, -0x20(%rbp)
jne 0xa8fa
cmpq $0x0, -0x28(%rbp)
jne 0xa8e5
movl -0x1c(%rbp), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9420
movq %rax, -0x8(%rbp)
jmp 0xa927
movq -0x28(%rbp), %rax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x7190
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
subl $0x7f, %eax
addl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shlq $0x1d, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x9420
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/./softfp_template.h
// Function: cvt_sf64_sf32
uint32_t glue(glue(cvt_sf, F_SIZE), _sf32)(F_UINT a, RoundingModeEnum rm,
                                           uint32_t *pfflags)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x24(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaa80
movq %rax, -0x30(%rbp)
cmpl $0x7ff, -0x28(%rbp)     # imm = 0x7FF
jne 0xa9f1
cmpq $0x0, -0x30(%rbp)
je 0xa9dd
movq -0x10(%rbp), %rdi
callq 0x8dc0
cmpl $0x0, %eax
je 0xa9d1
movq -0x20(%rbp), %rax
movl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movl $0x7fc00000, -0x4(%rbp) # imm = 0x7FC00000
jmp 0xaa6b
movl -0x24(%rbp), %edi
movl $0xff, %esi
xorl %edx, %edx
callq 0x7160
movl %eax, -0x4(%rbp)
jmp 0xaa6b
cmpl $0x0, -0x28(%rbp)
jne 0xaa1e
cmpq $0x0, -0x30(%rbp)
jne 0xaa0f
movl -0x24(%rbp), %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x7160
movl %eax, -0x4(%rbp)
jmp 0xaa6b
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x9460
jmp 0xaa30
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
subl $0x3ff, %eax            # imm = 0x3FF
addl $0x7f, %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl $0x16, %esi
callq 0x9080
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %rax
movl %eax, %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
callq 0x6eb0
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/./softfp_template.h
// Function: mul_u128
static F_UINT mul_u(F_UINT *plow, F_UINT a, F_UINT b)
{
    F_UHALF a0, a1, b0, b1, r0, r1, r2, r3;
    F_UINT r00, r01, r10, r11, c;
    a0 = a;
    a1 = a >> FH_SIZE;
    b0 = b;
    b1 = b >> FH_SIZE;

    r00 = (F_UINT)a0 * (F_UINT)b0;
    r01 = (F_UINT)a0 * (F_UINT)b1;
    r10 = (F_UINT)a1 * (F_UINT)b0;
    r11 = (F_UINT)a1 * (F_UINT)b1;
    
    r0 = r00;
    c = (r00 >> FH_SIZE) + (F_UHALF)r01 + (F_UHALF)r10;
    r1 = c;
    c = (c >> FH_SIZE) + (r01 >> FH_SIZE) + (r10 >> FH_SIZE) + (F_UHALF)r11;
    r2 = c;
    r3 = (c >> FH_SIZE) + (r11 >> FH_SIZE);

    *plow = ((F_UINT)r1 << FH_SIZE) | r0;
    return ((F_UINT)r3 << FH_SIZE) | r2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rsi
movq %rcx, -0x30(%rbp)
movq %r8, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdi, -0x38(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rax
movq -0x78(%rbp), %rcx
mulq %rcx
movq %rdx, -0xa8(%rbp)
movq %rax, -0xb0(%rbp)
movq -0x68(%rbp), %rax
movq -0x80(%rbp), %rcx
mulq %rcx
movq %rdx, -0xb8(%rbp)
movq %rax, -0xc0(%rbp)
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
mulq %rcx
movq %rdx, -0xc8(%rbp)
movq %rax, -0xd0(%rbp)
movq -0x70(%rbp), %rax
movq -0x80(%rbp), %rcx
mulq %rcx
movq %rdx, -0xd8(%rbp)
movq %rax, -0xe0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0xa8(%rbp), %rcx
movq -0xc0(%rbp), %rax
addq %rax, %rcx
setb %al
movzbl %al, %eax
movq -0xd0(%rbp), %rdx
addq %rdx, %rcx
adcq $0x0, %rax
movq %rcx, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0xe8(%rbp), %rcx
movq -0xb8(%rbp), %rax
addq %rax, %rcx
setb %al
movzbl %al, %eax
movq -0xc8(%rbp), %rdx
addq %rdx, %rcx
adcq $0x0, %rax
movq -0xe0(%rbp), %rdx
addq %rdx, %rcx
adcq $0x0, %rax
movq %rcx, -0xf0(%rbp)
movq %rax, -0xe8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xe8(%rbp), %rax
movq -0xd8(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq -0xa0(%rbp), %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: divrem_u128
static F_UINT divrem_u(F_UINT *pr, F_UINT a1, F_UINT a0, F_UINT b)
{
    int i, qb, ab;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq 0x18(%rbp), %rax
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rsi
movq %rcx, -0x30(%rbp)
movq %r8, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdi, -0x38(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rax
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rcx
subq %rsi, %rdx
sbbq %rcx, %rax
jae 0xdf80
jmp 0xdf7e
jmp 0xdf9f
leaq 0x1785e(%rip), %rdi     # 0x257e5
leaq 0x17641(%rip), %rsi     # 0x255cf
movl $0x23b, %edx            # imm = 0x23B
leaq 0x17852(%rip), %rcx     # 0x257ec
callq 0x1060
movl $0x0, -0x64(%rbp)
cmpl $0x80, -0x64(%rbp)
jge 0xe061
movq -0x48(%rbp), %rax
shrq $0x3f, %rax
movl %eax, -0x6c(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
shldq $0x1, %rax, %rcx
movq -0x58(%rbp), %rdx
shldq $0x1, %rdx, %rax
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x6c(%rbp)
jne 0xdffc
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rax
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rcx
subq %rsi, %rdx
sbbq %rcx, %rax
jb 0xe023
jmp 0xdffc
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
subq %rsi, %rcx
sbbq %rdx, %rax
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0xe02a
movl $0x0, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
shldq $0x1, %rax, %rcx
addq %rax, %rax
movslq -0x68(%rbp), %rsi
movq %rsi, %rdx
sarq $0x3f, %rdx
orq %rsi, %rax
orq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0xdfa6
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rax
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfp_template.h
// Function: cvt_sf64_sf128
F_UINT cvt_sf64_sf(uint64_t a, uint32_t *pfflags)
{
    uint32_t a_sign;
    int32_t a_exp;
    F_UINT a_mant;

    a_mant = unpack_sf64(&a_sign, &a_exp, a);

    if (a_exp == 0x7ff) {
        if (a_mant != 0) {
            /* NaN */
            if (issignan_sf64(a)) {
                *pfflags |= FFLAG_INVALID_OP;
            }
            return F_QNAN;
        } else {
            /* infinity */
            return pack_sf(a_sign, EXP_MASK, 0);
        }
    }
    if (a_exp == 0) {
        if (a_mant == 0)
            return pack_sf(a_sign, 0, 0); /* zero */
        a_mant = normalize_subnormal_sf64(&a_exp, a_mant);
    }
    /* convert the exponent value */
    a_exp = a_exp - 0x3ff + (EXP_MASK / 2);
    /* shift the mantissa */
    a_mant <<= (MANT_SIZE - 52);
    return pack_sf(a_sign, a_exp, a_mant);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x24(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaa80
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
cmpl $0x7ff, -0x28(%rbp)     # imm = 0x7FF
jne 0xf592
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
orq %rcx, %rax
je 0xf550
jmp 0xf51c
movq -0x18(%rbp), %rdi
callq 0x8dc0
cmpl $0x0, %eax
je 0xf535
movq -0x20(%rbp), %rax
movl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movabsq $0x7fff800000000000, %rax # imm = 0x7FFF800000000000
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
jmp 0xf679
movl -0x24(%rbp), %edi
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x7fff, %esi           # imm = 0x7FFF
callq 0xc4b0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
jmp 0xf679
cmpl $0x0, -0x28(%rbp)
jne 0xf5ff
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
orq %rcx, %rax
jne 0xf5e6
jmp 0xf5a7
movl -0x24(%rbp), %edi
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
xorl %esi, %esi
callq 0xc4b0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
jmp 0xf679
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x9460
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movl -0x28(%rbp), %eax
addl $0x3c00, %eax           # imm = 0x3C00
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %rdx, %rax
shlq $0x3c, %rax
shldq $0x3c, %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0xc4b0
movq %rax, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfp.c
// Function: clz32
static inline int clz32(uint32_t a)
{
    int r;
    if (a == 0) {
        r = 32;
    } else {
        r = __builtin_clz(a);
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x109e6
movl $0x20, -0x8(%rbp)
jmp 0x109f2
movl -0x4(%rbp), %eax
bsrl %eax, %eax
xorl $0x1f, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfp.c
// Function: clz64
static inline int clz64(uint64_t a)
{
    int r;
    if (a == 0) {
        r = 64;
    } else 
    {
        r = __builtin_clzll(a);
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10ba8
movl $0x40, -0xc(%rbp)
jmp 0x10bb7
movq -0x8(%rbp), %rax
bsrq %rax, %rax
xorq $0x3f, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfp.c
// Function: clz128
static inline int clz128(uint128_t a)
{
    int r;
    if (a == 0) {
        r = 128;
    } else 
    {
        uint64_t ah, al;
        ah = a >> 64;
        al = a;
        if (ah != 0)
            r = __builtin_clzll(ah);
        else
            r = __builtin_clzll(al) + 64;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
orq %rcx, %rax
jne 0x10bf4
jmp 0x10beb
movl $0x80, -0x24(%rbp)
jmp 0x10c30
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x10c1c
movq -0x30(%rbp), %rax
bsrq %rax, %rax
xorq $0x3f, %rax
movl %eax, -0x24(%rbp)
jmp 0x10c2e
movq -0x38(%rbp), %rax
bsrq %rax, %rax
xorq $0x3f, %rax
addl $0x40, %eax
movl %eax, -0x24(%rbp)
jmp 0x10c30
movl -0x24(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float16_maybe_silence_nan
float16 float16_maybe_silence_nan(float16 a_)
{
    if (float16_is_signaling_nan(a_)) {
#if SNAN_BIT_IS_ONE
#  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
        return float16_default_nan;
#  else
#    error Rules for silencing a signaling NaN are target-specific
#  endif
#else
        uint16_t a = float16_val(a_);
        a |= (1 << 9);
        return make_float16(a);
#endif
    }
    return a_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %edi
callq 0x110e0
cmpl $0x0, %eax
je 0x1116c
movw -0x4(%rbp), %ax
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %eax
orl $0x200, %eax            # imm = 0x200
movw %ax, -0x6(%rbp)
movw -0x6(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x11174
movw -0x4(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float32_maybe_silence_nan
float32 float32_maybe_silence_nan( float32 a_ )
{
    if (float32_is_signaling_nan(a_)) {
#if SNAN_BIT_IS_ONE
#  if defined(TARGET_MIPS) || defined(TARGET_SH4) || defined(TARGET_UNICORE32)
        return float32_default_nan;
#  else
#    error Rules for silencing a signaling NaN are target-specific
#  endif
#else
        uint32_t a = float32_val(a_);
        a |= (1 << 22);
        return make_float32(a);
#endif
    }
    return a_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x111b0
cmpl $0x0, %eax
je 0x11231
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
orl $0x400000, %eax         # imm = 0x400000
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11237
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq