LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int32_round_to_zero
int32 float64_to_int32_round_to_zero(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig, savedASig;
    int32_t z;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( 0x41E < aExp ) {
        if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
        goto invalid;
    }
    else if ( aExp < 0x3FF ) {
        if (aExp || aSig) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    aSig |= LIT64( 0x0010000000000000 );
    shiftCount = 0x433 - aExp;
    savedASig = aSig;
    aSig >>= shiftCount;
    z = aSig;
    if ( aSign ) z = - z;
    if ( ( z < 0 ) ^ aSign ) {
 invalid:
        float_raise(float_flag_invalid, status);
        return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
    }
    if ( ( aSig<<shiftCount ) != savedASig ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11680
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x19(%rbp)
movl $0x41e, %eax            # imm = 0x41E
cmpq -0x28(%rbp), %rax
jge 0x1697c
cmpq $0x7ff, -0x28(%rbp)     # imm = 0x7FF
jne 0x16977
cmpq $0x0, -0x38(%rbp)
je 0x16977
movb $0x0, -0x19(%rbp)
jmp 0x16a14
cmpq $0x3ff, -0x28(%rbp)     # imm = 0x3FF
jge 0x169ae
cmpq $0x0, -0x28(%rbp)
jne 0x16994
cmpq $0x0, -0x38(%rbp)
je 0x169a2
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x16a60
jmp 0x169b0
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x433, %eax            # imm = 0x433
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
shrq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x44(%rbp)
cmpb $0x0, -0x19(%rbp)
je 0x169fb
xorl %eax, %eax
subl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movzbl -0x19(%rbp), %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x16a3b
jmp 0x16a14
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movzbl -0x19(%rbp), %edx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x80000000, %ecx       # imm = 0x80000000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x16a60
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq %cl, %rax
cmpq -0x40(%rbp), %rax
je 0x16a5a
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int16_round_to_zero
int_fast16_t float64_to_int16_round_to_zero(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig, savedASig;
    int32 z;

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( 0x40E < aExp ) {
        if ( ( aExp == 0x7FF ) && aSig ) {
            aSign = 0;
        }
        goto invalid;
    }
    else if ( aExp < 0x3FF ) {
        if ( aExp || aSig ) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    aSig |= LIT64( 0x0010000000000000 );
    shiftCount = 0x433 - aExp;
    savedASig = aSig;
    aSig >>= shiftCount;
    z = aSig;
    if ( aSign ) {
        z = - z;
    }
    if ( ( (int16_t)z < 0 ) ^ aSign ) {
 invalid:
        float_raise(float_flag_invalid, status);
        return aSign ? (int32_t) 0xffff8000 : 0x7FFF;
    }
    if ( ( aSig<<shiftCount ) != savedASig ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x116a0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11680
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x19(%rbp)
movl $0x40e, %eax            # imm = 0x40E
cmpq -0x28(%rbp), %rax
jge 0x16acb
cmpq $0x7ff, -0x28(%rbp)     # imm = 0x7FF
jne 0x16ac6
cmpq $0x0, -0x38(%rbp)
je 0x16ac6
movb $0x0, -0x19(%rbp)
jmp 0x16b67
cmpq $0x3ff, -0x28(%rbp)     # imm = 0x3FF
jge 0x16afe
cmpq $0x0, -0x28(%rbp)
jne 0x16ae3
cmpq $0x0, -0x38(%rbp)
je 0x16af1
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x16bb8
jmp 0x16b00
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x433, %eax            # imm = 0x433
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
shrq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x44(%rbp)
cmpb $0x0, -0x19(%rbp)
je 0x16b4b
xorl %eax, %eax
subl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cwtl
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movzbl -0x19(%rbp), %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x16b91
jmp 0x16b67
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movzbl -0x19(%rbp), %edx
movl $0x7fff, %eax           # imm = 0x7FFF
movl $0xffff8000, %ecx       # imm = 0xFFFF8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x16bb8
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq %cl, %rax
cmpq -0x40(%rbp), %rax
je 0x16bb0
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movslq -0x44(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_int64
int64 float64_to_int64(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp, shiftCount;
    uint64_t aSig, aSigExtra;
    a = float64_squash_input_denormal(a, status);

    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp ) aSig |= LIT64( 0x0010000000000000 );
    shiftCount = 0x433 - aExp;
    if ( shiftCount <= 0 ) {
        if ( 0x43E < aExp ) {
            float_raise(float_flag_invalid, status);
            if (    ! aSign
                 || (    ( aExp == 0x7FF )
                      && ( aSig != LIT64( 0x0010000000000000 ) ) )
               ) {
                return LIT64( 0x7FFFFFFFFFFFFFFF );
            }
            return (int64_t) LIT64( 0x8000000000000000 );
        }
        aSigExtra = 0;
        aSig <<= - shiftCount;
    }
    else {
        shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
    }
    return roundAndPackInt64(aSign, aSig, aSigExtra, status);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11680
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x19(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x16c30
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x433, %eax            # imm = 0x433
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jg 0x16cba
movl $0x43e, %eax            # imm = 0x43E
cmpq -0x28(%rbp), %rax
jge 0x16c9d
movq -0x18(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
cmpb $0x0, -0x19(%rbp)
je 0x16c7d
cmpq $0x7ff, -0x28(%rbp)     # imm = 0x7FF
jne 0x16c8d
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
cmpq %rax, -0x38(%rbp)
je 0x16c8d
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0x16cee
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x8(%rbp)
jmp 0x16cee
movq $0x0, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %ecx
subq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
shlq %cl, %rax
movq %rax, -0x38(%rbp)
jmp 0x16cd3
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x12ce0
movb -0x19(%rbp), %al
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rcx
movzbl %al, %edi
callq 0x12dc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: commonNaNToFloat32
static float32 commonNaNToFloat32(commonNaNT a, float_status *status)
{
    uint32_t mantissa = a.high>>41;

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

    if ( mantissa )
        return make_float32(
            ( ( (uint32_t) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) );
    else
        return float32_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 $0x29, %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x16ebe
movl $0x7fc00000, -0x4(%rbp) # imm = 0x7FC00000
jmp 0x16eec
cmpl $0x0, -0x14(%rbp)
je 0x16ee5
movq -0x20(%rbp), %rcx
movzbl (%rcx), %eax
shll $0x1f, %eax
orl $0x7f800000, %eax       # imm = 0x7F800000
movl %eax, %eax
movq 0x8(%rcx), %rcx
shrq $0x29, %rcx
orq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x16eec
movl $0x7fc00000, -0x4(%rbp) # imm = 0x7FC00000
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float64ToCommonNaN
static commonNaNT float64ToCommonNaN(float64 a, float_status *status)
{
    commonNaNT z;

    if (float64_is_signaling_nan(a)) {
        float_raise(float_flag_invalid, status);
    }
    z.sign = float64_val(a)>>63;
    z.low = 0;
    z.high = float64_val(a)<<12;
    return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11270
cmpl $0x0, %eax
je 0x16f34
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
shrq $0x3f, %rdx
movb %dl, (%rcx)
movq $0x0, 0x10(%rcx)
movq -0x8(%rbp), %rdx
shlq $0xc, %rdx
movq %rdx, 0x8(%rcx)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float16_to_float32
float32 float16_to_float32(float16 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;

    aSign = extractFloat16Sign(a);
    aExp = extractFloat16Exp(a);
    aSig = extractFloat16Frac(a);

    if (aExp == 0x1f && ieee) {
        if (aSig) {
            return commonNaNToFloat32(float16ToCommonNaN(a, status), status);
        }
        return packFloat32(aSign, 0xff, 0);
    }
    if (aExp == 0) {
        if (aSig == 0) {
            return packFloat32(aSign, 0, 0);
        }

        normalizeFloat16Subnormal(aSig, &aExp, &aSig);
        aExp--;
    }
    return packFloat32( aSign, aExp + 0x70, aSig << 13);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movw %di, %cx
movw %cx, -0x6(%rbp)
movb %al, -0x7(%rbp)
movq %rdx, -0x10(%rbp)
movzwl -0x6(%rbp), %edi
callq 0x17070
movb %al, -0x11(%rbp)
movzwl -0x6(%rbp), %edi
callq 0x17090
movq %rax, -0x20(%rbp)
movzwl -0x6(%rbp), %edi
callq 0x170b0
movl %eax, -0x24(%rbp)
cmpq $0x1f, -0x20(%rbp)
jne 0x17008
movzbl -0x7(%rbp), %eax
cmpl $0x0, %eax
je 0x17008
cmpl $0x0, -0x24(%rbp)
je 0x16ff3
movw -0x6(%rbp), %ax
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movzwl %ax, %esi
callq 0x170d0
movq -0x10(%rbp), %rdi
leaq -0x40(%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 0x17061
movl $0xff, %esi
xorl %edx, %edx
movzbl -0x11(%rbp), %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x17061
cmpq $0x0, -0x20(%rbp)
jne 0x17045
cmpl $0x0, -0x24(%rbp)
jne 0x17029
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movzbl -0x11(%rbp), %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x17061
movl -0x24(%rbp), %edi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x17140
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rsi
addq $0x70, %rsi
movl -0x24(%rbp), %edx
shll $0xd, %edx
movzbl %al, %edi
callq 0x11750
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: float16ToCommonNaN
static commonNaNT float16ToCommonNaN(float16 a, float_status *status)
{
    commonNaNT z;

    if (float16_is_signaling_nan(a)) {
        float_raise(float_flag_invalid, status);
    }
    z.sign = float16_val(a) >> 15;
    z.low = 0;
    z.high = ((uint64_t) float16_val(a))<<54;
    return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movw %si, %ax
movq %rdi, -0x18(%rbp)
movw %ax, -0x2(%rbp)
movq %rdx, -0x10(%rbp)
movzwl -0x2(%rbp), %edi
callq 0x110e0
cmpl $0x0, %eax
je 0x17107
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl -0x2(%rbp), %edx
sarl $0xf, %edx
movb %dl, (%rcx)
movq $0x0, 0x10(%rcx)
movzwl -0x2(%rbp), %edx
shlq $0x36, %rdx
movq %rdx, 0x8(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: commonNaNToFloat16
static float16 commonNaNToFloat16(commonNaNT a, float_status *status)
{
    uint16_t mantissa = a.high>>54;

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

    if (mantissa) {
        return make_float16(((((uint16_t) a.sign) << 15)
                             | (0x1F << 10) | mantissa));
    } else {
        return float16_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 $0x36, %rax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x1735e
movw $0xfe00, -0x2(%rbp)     # imm = 0xFE00
jmp 0x17389
cmpw $0x0, -0x12(%rbp)
je 0x17383
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movzwl %ax, %eax
shll $0xf, %eax
orl $0x7c00, %eax           # imm = 0x7C00
movzwl -0x12(%rbp), %ecx
orl %ecx, %eax
movw %ax, -0x2(%rbp)
jmp 0x17389
movw $0xfe00, -0x2(%rbp)     # imm = 0xFE00
movw -0x2(%rbp), %ax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float16_to_float64
float64 float16_to_float64(float16 a, flag ieee, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint32_t aSig;

    aSign = extractFloat16Sign(a);
    aExp = extractFloat16Exp(a);
    aSig = extractFloat16Frac(a);

    if (aExp == 0x1f && ieee) {
        if (aSig) {
            return commonNaNToFloat64(
                float16ToCommonNaN(a, status), status);
        }
        return packFloat64(aSign, 0x7ff, 0);
    }
    if (aExp == 0) {
        if (aSig == 0) {
            return packFloat64(aSign, 0, 0);
        }

        normalizeFloat16Subnormal(aSig, &aExp, &aSig);
        aExp--;
    }
    return packFloat64(aSign, aExp + 0x3f0, ((uint64_t)aSig) << 42);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movw %di, %cx
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq %rdx, -0x18(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x17070
movb %al, -0x19(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x17090
movq %rax, -0x28(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x170b0
movl %eax, -0x2c(%rbp)
cmpq $0x1f, -0x28(%rbp)
jne 0x176cc
movzbl -0xb(%rbp), %eax
cmpl $0x0, %eax
je 0x176cc
cmpl $0x0, -0x2c(%rbp)
je 0x176b4
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movzwl %ax, %esi
callq 0x170d0
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 0x1772e
movl $0x7ff, %esi            # imm = 0x7FF
xorl %eax, %eax
movl %eax, %edx
movzbl -0x19(%rbp), %edi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x1772e
cmpq $0x0, -0x28(%rbp)
jne 0x1770b
cmpl $0x0, -0x2c(%rbp)
jne 0x176ef
xorl %eax, %eax
movl %eax, %edx
movzbl -0x19(%rbp), %edi
movq %rdx, %rsi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x1772e
movl -0x2c(%rbp), %edi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x17140
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %al
movq -0x28(%rbp), %rsi
addq $0x3f0, %rsi            # imm = 0x3F0
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
shlq $0x2a, %rdx
movzbl %al, %edi
callq 0x118b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_floatx80
floatx80 float64_to_floatx80(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig;

    a = float64_squash_input_denormal(a, status);
    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp == 0x7FF ) {
        if (aSig) {
            return commonNaNToFloatx80(float64ToCommonNaN(a, status), status);
        }
        return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
    }
    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
        normalizeFloat64Subnormal( aSig, &aExp, &aSig );
    }
    return
        packFloatx80(
            aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11610
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x116a0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11680
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x168f0
movb %al, -0x21(%rbp)
cmpq $0x7ff, -0x30(%rbp)     # imm = 0x7FF
jne 0x1799e
cmpq $0x0, -0x38(%rbp)
je 0x1797c
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x16f00
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 0x17a08
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 0x17a08
cmpq $0x0, -0x30(%rbp)
jne 0x179d6
cmpq $0x0, -0x38(%rbp)
jne 0x179c5
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movzbl -0x21(%rbp), %edi
callq 0x11990
movq %rax, -0x10(%rbp)
movw %dx, -0x8(%rbp)
jmp 0x17a08
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x17a20
movb -0x21(%rbp), %al
movq -0x30(%rbp), %rcx
addq $0x3c00, %rcx           # imm = 0x3C00
movl %ecx, %esi
movabsq $0x10000000000000, %rdx # imm = 0x10000000000000
orq -0x38(%rbp), %rdx
shlq $0xb, %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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_to_float128
float128 float64_to_float128(float64 a, float_status *status)
{
    flag aSign;
    int_fast16_t aExp;
    uint64_t aSig, zSig0, zSig1;

    a = float64_squash_input_denormal(a, status);
    aSig = extractFloat64Frac( a );
    aExp = extractFloat64Exp( a );
    aSign = extractFloat64Sign( a );
    if ( aExp == 0x7FF ) {
        if (aSig) {
            return commonNaNToFloat128(float64ToCommonNaN(a, status), status);
        }
        return packFloat128( aSign, 0x7FFF, 0, 0 );
    }
    if ( aExp == 0 ) {
        if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
        normalizeFloat64Subnormal( aSig, &aExp, &aSig );
        --aExp;
    }
    shift128Right( aSig, 0, 4, &zSig0, &zSig1 );
    return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11610
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x116a0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11680
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x168f0
movb %al, -0x21(%rbp)
cmpq $0x7ff, -0x30(%rbp)     # imm = 0x7FF
jne 0x17b41
cmpq $0x0, -0x38(%rbp)
je 0x17b1f
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x16f00
movq -0x20(%rbp), %rdi
leaq -0x60(%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 0x17bca
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 0x17bca
cmpq $0x0, -0x30(%rbp)
jne 0x17b88
cmpq $0x0, -0x38(%rbp)
jne 0x17b6b
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 0x17bca
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x17a20
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x4, %edx
leaq -0x40(%rbp), %rcx
leaq -0x48(%rbp), %r8
callq 0x17be0
movb -0x21(%rbp), %al
movq -0x30(%rbp), %rcx
addq $0x3c00, %rcx           # imm = 0x3C00
movl %ecx, %esi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movzbl %al, %edi
callq 0x11a80
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift128Right
static inline void
 shift128Right(
     uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
{
    uint64_t z0, z1;
    int8 negCount = ( - count ) & 63;

    if ( count == 0 ) {
        z1 = a1;
        z0 = a0;
    }
    else if ( count < 64 ) {
        z1 = ( a0<<negCount ) | ( a1>>count );
        z0 = a0>>count;
    }
    else {
        z1 = (count < 128) ? (a0 >> (count & 63)) : 0;
        z0 = 0;
    }
    *z1Ptr = z1;
    *z0Ptr = z0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
xorl %eax, %eax
subq -0x18(%rbp), %rax
andq $0x3f, %rax
movb %al, -0x39(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17c1e
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x17c91
cmpq $0x40, -0x18(%rbp)
jge 0x17c58
movq -0x8(%rbp), %rax
movsbl -0x39(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq %cl, %rax
movq %rax, -0x30(%rbp)
jmp 0x17c8f
cmpq $0x80, -0x18(%rbp)
jge 0x17c77
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
movq %rax, -0x48(%rbp)
jmp 0x17c7f
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x17c7f
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
jmp 0x17c91
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-specialize.h
// Function: propagateFloat64NaN
static float64 propagateFloat64NaN(float64 a, float64 b, float_status *status)
{
    flag aIsQuietNaN, aIsSignalingNaN, bIsQuietNaN, bIsSignalingNaN;
    flag aIsLargerSignificand;
    uint64_t av, bv;

    aIsQuietNaN = float64_is_quiet_nan( a );
    aIsSignalingNaN = float64_is_signaling_nan( a );
    bIsQuietNaN = float64_is_quiet_nan( b );
    bIsSignalingNaN = float64_is_signaling_nan( b );
    av = float64_val(a);
    bv = float64_val(b);

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

    if (status->default_nan_mode)
        return float64_default_nan;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11240
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11270
movb %al, -0x22(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11240
movb %al, -0x23(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11270
movb %al, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movzbl -0x22(%rbp), %eax
movzbl -0x24(%rbp), %ecx
orl %ecx, %eax
cmpl $0x0, %eax
je 0x17fe1
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movq -0x20(%rbp), %rax
cmpb $0x0, 0x6(%rax)
je 0x17ffe
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, -0x8(%rbp)
jmp 0x1808f
movq -0x30(%rbp), %rax
shlq %rax
movq -0x38(%rbp), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x18017
movb $0x0, -0x25(%rbp)
jmp 0x1804a
movq -0x38(%rbp), %rax
shlq %rax
movq -0x30(%rbp), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x18030
movb $0x1, -0x25(%rbp)
jmp 0x18048
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movb %al, -0x25(%rbp)
jmp 0x1804a
movb -0x21(%rbp), %sil
movb -0x22(%rbp), %dl
movb -0x23(%rbp), %cl
movb -0x24(%rbp), %al
movzbl %sil, %edi
movzbl %dl, %esi
movzbl %cl, %edx
movzbl %al, %ecx
movzbl -0x25(%rbp), %r8d
callq 0x24100
cmpl $0x0, %eax
je 0x18082
movq -0x18(%rbp), %rdi
callq 0x112c0
movq %rax, -0x8(%rbp)
jmp 0x1808f
movq -0x10(%rbp), %rdi
callq 0x112c0
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: float64_trunc_to_int
float64 float64_trunc_to_int(float64 a, float_status *status)
{
    int oldmode;
    float64 res;
    oldmode = status->float_rounding_mode;
    status->float_rounding_mode = float_round_to_zero;
    res = float64_round_to_int(a, status);
    status->float_rounding_mode = oldmode;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb $0x3, 0x1(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17cb0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: mul64To128
static inline void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr )
{
    uint32_t aHigh, aLow, bHigh, bLow;
    uint64_t z0, zMiddleA, zMiddleB, z1;

    aLow = a;
    aHigh = a>>32;
    bLow = b;
    bHigh = b>>32;
    z1 = ( (uint64_t) aLow ) * bLow;
    zMiddleA = ( (uint64_t) aLow ) * bHigh;
    zMiddleB = ( (uint64_t) aHigh ) * bLow;
    z0 = ( (uint64_t) aHigh ) * bHigh;
    zMiddleA += zMiddleB;
    z0 += ( ( (uint64_t) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );
    zMiddleA <<= 32;
    z1 += zMiddleA;
    z0 += ( z1 < zMiddleA );
    *z1Ptr = z1;
    *z0Ptr = z0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movl -0x30(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x28(%rbp), %eax
movl -0x2c(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl -0x30(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %eax
movl -0x2c(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
shlq $0x20, %rax
movq -0x40(%rbp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x40(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfloat-macros.h
// Function: shift128RightJamming
static inline void
 shift128RightJamming(
     uint64_t a0, uint64_t a1, int_fast16_t count, uint64_t *z0Ptr, uint64_t *z1Ptr)
{
    uint64_t z0, z1;
    int8 negCount = ( - count ) & 63;

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
xorl %eax, %eax
subq -0x18(%rbp), %rax
andq $0x3f, %rax
movb %al, -0x39(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x19c61
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x19d52
cmpq $0x40, -0x18(%rbp)
jge 0x19cc1
movq -0x8(%rbp), %rax
movsbl -0x39(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rdx
movsbl -0x39(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq %cl, %rax
movq %rax, -0x30(%rbp)
jmp 0x19d50
cmpq $0x40, -0x18(%rbp)
jne 0x19ce6
movq -0x8(%rbp), %rax
cmpq $0x0, -0x10(%rbp)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x19d48
cmpq $0x80, -0x18(%rbp)
jge 0x19d2c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
movq -0x8(%rbp), %rdx
movsbl -0x39(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
orq -0x10(%rbp), %rcx
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x19d46
movq -0x8(%rbp), %rax
orq -0x10(%rbp), %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x38(%rbp)
jmp 0x19d48
movq $0x0, -0x30(%rbp)
jmp 0x19d52
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_eq
int float64_eq(float64 a, float64 b, float_status *status)
{
    uint64_t av, bv;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    av = float64_val(a);
    bv = float64_val(b);
    return ( av == bv ) || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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 0x11680
cmpq $0x7ff, %rax            # imm = 0x7FF
jne 0x1a256
movq -0x10(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
jne 0x1a276
movq -0x18(%rbp), %rdi
callq 0x11680
cmpq $0x7ff, %rax            # imm = 0x7FF
jne 0x1a28d
movq -0x18(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
je 0x1a28d
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x1a2cc
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movb $0x1, %al
cmpq -0x30(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x1a2c1
movq -0x28(%rbp), %rax
orq -0x30(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_le
int float64_le(float64 a, float64 b, float_status *status)
{
    flag aSign, bSign;
    uint64_t av, bv;
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 0;
    }
    aSign = extractFloat64Sign( a );
    bSign = extractFloat64Sign( b );
    av = float64_val(a);
    bv = float64_val(b);
    if ( aSign != bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );
    return ( av == bv ) || ( aSign ^ ( av < bv ) );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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 0x11680
cmpq $0x7ff, %rax            # imm = 0x7FF
jne 0x1a336
movq -0x10(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
jne 0x1a356
movq -0x18(%rbp), %rdi
callq 0x11680
cmpq $0x7ff, %rax            # imm = 0x7FF
jne 0x1a370
movq -0x18(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
je 0x1a370
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x0, -0x4(%rbp)
jmp 0x1a40e
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x168f0
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movzbl -0x21(%rbp), %eax
movzbl -0x22(%rbp), %ecx
cmpl %ecx, %eax
je 0x1a3d4
movzbl -0x21(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
jne 0x1a3c7
movq -0x30(%rbp), %rax
orq -0x38(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1a40e
movq -0x30(%rbp), %rcx
movb $0x1, %al
cmpq -0x38(%rbp), %rcx
movb %al, -0x3a(%rbp)
je 0x1a403
movzbl -0x21(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpq -0x38(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
andb $0x1, %al
movzbl %al, %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/softfloat.c
// Function: float64_unordered
int float64_unordered(float64 a, float64 b, float_status *status)
{
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
       ) {
        float_raise(float_flag_invalid, status);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x11680
cmpq $0x7ff, %rax            # imm = 0x7FF
jne 0x1a5b6
movq -0x10(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
jne 0x1a5d6
movq -0x18(%rbp), %rdi
callq 0x11680
cmpq $0x7ff, %rax            # imm = 0x7FF
jne 0x1a5ed
movq -0x18(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
je 0x1a5ed
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x1, -0x4(%rbp)
jmp 0x1a5f4
movl $0x0, -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: float64_unordered_quiet
int float64_unordered_quiet(float64 a, float64 b, float_status *status)
{
    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);

    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )
         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )
       ) {
        if ( float64_is_signaling_nan( a ) || float64_is_signaling_nan( b ) ) {
            float_raise(float_flag_invalid, status);
        }
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x11680
cmpq $0x7ff, %rax            # imm = 0x7FF
jne 0x1aa16
movq -0x10(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
jne 0x1aa36
movq -0x18(%rbp), %rdi
callq 0x11680
cmpq $0x7ff, %rax            # imm = 0x7FF
jne 0x1aa69
movq -0x18(%rbp), %rdi
callq 0x116a0
cmpq $0x0, %rax
je 0x1aa69
movq -0x10(%rbp), %rdi
callq 0x11270
cmpl $0x0, %eax
jne 0x1aa52
movq -0x18(%rbp), %rdi
callq 0x11270
cmpl $0x0, %eax
je 0x1aa60
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x1, -0x4(%rbp)
jmp 0x1aa70
movl $0x0, -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: floatx80_to_int32
int32 floatx80_to_int32(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
    shiftCount = 0x4037 - aExp;
    if ( shiftCount <= 0 ) shiftCount = 1;
    shift64RightJamming( aSig, shiftCount, &aSig );
    return roundAndPackInt32(aSign, aSig, status);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x8(%rbp), %esi
callq 0x1ab30
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x8(%rbp), %esi
callq 0x1ab50
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x8(%rbp), %esi
callq 0x1ab70
movb %al, -0x19(%rbp)
cmpl $0x7fff, -0x20(%rbp)    # imm = 0x7FFF
jne 0x1aae2
movq -0x30(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
je 0x1aae2
movb $0x0, -0x19(%rbp)
movl $0x4037, %eax           # imm = 0x4037
subl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jg 0x1aafa
movl $0x1, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11c20
movb -0x19(%rbp), %al
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl %al, %edi
callq 0x12820
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int32_round_to_zero
int32 floatx80_to_int32_round_to_zero(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig, savedASig;
    int32_t z;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    if ( 0x401E < aExp ) {
        if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
        goto invalid;
    }
    else if ( aExp < 0x3FFF ) {
        if (aExp || aSig) {
            status->float_exception_flags |= float_flag_inexact;
        }
        return 0;
    }
    shiftCount = 0x403E - aExp;
    savedASig = aSig;
    aSig >>= shiftCount;
    z = aSig;
    if ( aSign ) z = - z;
    if ( ( z < 0 ) ^ aSign ) {
 invalid:
        float_raise(float_flag_invalid, status);
        return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
    }
    if ( ( aSig<<shiftCount ) != savedASig ) {
        status->float_exception_flags |= float_flag_inexact;
    }
    return z;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %si, %ax
movq %rdi, -0x18(%rbp)
movw %ax, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1ab30
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1ab50
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1ab70
movb %al, -0x21(%rbp)
movl $0x401e, %eax           # imm = 0x401E
cmpl -0x28(%rbp), %eax
jge 0x1ac01
cmpl $0x7fff, -0x28(%rbp)    # imm = 0x7FFF
jne 0x1abfc
movq -0x38(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
je 0x1abfc
movb $0x0, -0x21(%rbp)
jmp 0x1ac84
cmpl $0x3fff, -0x28(%rbp)    # imm = 0x3FFF
jge 0x1ac31
cmpl $0x0, -0x28(%rbp)
jne 0x1ac17
cmpq $0x0, -0x38(%rbp)
je 0x1ac25
movq -0x20(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1accf
jmp 0x1ac33
movl $0x403e, %eax           # imm = 0x403E
subl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x44(%rbp)
cmpb $0x0, -0x21(%rbp)
je 0x1ac6b
xorl %eax, %eax
subl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movzbl -0x21(%rbp), %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x1acab
jmp 0x1ac84
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movzbl -0x21(%rbp), %edx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x80000000, %ecx       # imm = 0x80000000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1accf
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq %cl, %rax
cmpq -0x40(%rbp), %rax
je 0x1acc9
movq -0x20(%rbp), %rax
movsbl 0x2(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x2(%rax)
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: floatx80_to_int64
int64 floatx80_to_int64(floatx80 a, float_status *status)
{
    flag aSign;
    int32 aExp, shiftCount;
    uint64_t aSig, aSigExtra;

    aSig = extractFloatx80Frac( a );
    aExp = extractFloatx80Exp( a );
    aSign = extractFloatx80Sign( a );
    shiftCount = 0x403E - aExp;
    if ( shiftCount <= 0 ) {
        if ( shiftCount ) {
            float_raise(float_flag_invalid, status);
            if (    ! aSign
                 || (    ( aExp == 0x7FFF )
                      && ( aSig != LIT64( 0x8000000000000000 ) ) )
               ) {
                return LIT64( 0x7FFFFFFFFFFFFFFF );
            }
            return (int64_t) LIT64( 0x8000000000000000 );
        }
        aSigExtra = 0;
    }
    else {
        shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
    }
    return roundAndPackInt64(aSign, aSig, aSigExtra, status);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x18(%rbp)
movw %ax, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1ab30
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1ab50
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1ab70
movb %al, -0x21(%rbp)
movl $0x403e, %eax           # imm = 0x403E
subl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jg 0x1ad96
cmpl $0x0, -0x2c(%rbp)
je 0x1ad8c
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
cmpb $0x0, -0x21(%rbp)
je 0x1ad6c
cmpl $0x7fff, -0x28(%rbp)    # imm = 0x7FFF
jne 0x1ad7c
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x38(%rbp)
je 0x1ad7c
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0x1adca
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x8(%rbp)
jmp 0x1adca
movq $0x0, -0x40(%rbp)
jmp 0x1adaf
movq -0x38(%rbp), %rdi
movslq -0x2c(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x12ce0
movb -0x21(%rbp), %al
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzbl %al, %edi
callq 0x12dc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)