// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float32_muladd
float32 float32_muladd(float32 a, float32 b, float32 c, int flags,
                       float_status *status)
{
    flag aSign, bSign, cSign, zSign;
    int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;
    uint32_t aSig, bSig, cSig;
    flag pInf, pZero, pSign;
    uint64_t pSig64, cSig64, zSig64;
    uint32_t pSig;
    int shiftcount;
    flag signflip, infzero;

    a = float32_squash_input_denormal(a, status);
    b = float32_squash_input_denormal(b, status);
    c = float32_squash_input_denormal(c, status);
    aSig = extractFloat32Frac(a);
    aExp = extractFloat32Exp(a);
    aSign = extractFloat32Sign(a);
    bSig = extractFloat32Frac(b);
    bExp = extractFloat32Exp(b);
    bSign = extractFloat32Sign(b);
    cSig = extractFloat32Frac(c);
    cExp = extractFloat32Exp(c);
    cSign = extractFloat32Sign(c);

    infzero = ((aExp == 0 && aSig == 0 && bExp == 0xff && bSig == 0) ||
               (aExp == 0xff && aSig == 0 && bExp == 0 && bSig == 0));

    /* It is implementation-defined whether the cases of (0,inf,qnan)
     * and (inf,0,qnan) raise InvalidOperation or not (and what QNaN
     * they return if they do), so we have to hand this information
     * off to the target-specific pick-a-NaN routine.
     */
    if (((aExp == 0xff) && aSig) ||
        ((bExp == 0xff) && bSig) ||
        ((cExp == 0xff) && cSig)) {
        return propagateFloat32MulAddNaN(a, b, c, infzero, status);
    }

    if (infzero) {
        float_raise(float_flag_invalid, status);
        return float32_default_nan;
    }

    if (flags & float_muladd_negate_c) {
        cSign ^= 1;
    }

    signflip = (flags & float_muladd_negate_result) ? 1 : 0;

    /* Work out the sign and type of the product */
    pSign = aSign ^ bSign;
    if (flags & float_muladd_negate_product) {
        pSign ^= 1;
    }
    pInf = (aExp == 0xff) || (bExp == 0xff);
    pZero = ((aExp | aSig) == 0) || ((bExp | bSig) == 0);

    if (cExp == 0xff) {
        if (pInf && (pSign ^ cSign)) {
            /* addition of opposite-signed infinities => InvalidOperation */
            float_raise(float_flag_invalid, status);
            return float32_default_nan;
        }
        /* Otherwise generate an infinity of the same sign */
        return packFloat32(cSign ^ signflip, 0xff, 0);
    }

    if (pInf) {
        return packFloat32(pSign ^ signflip, 0xff, 0);
    }

    if (pZero) {
        if (cExp == 0) {
            if (cSig == 0) {
                /* Adding two exact zeroes */
                if (pSign == cSign) {
                    zSign = pSign;
                } else if (status->float_rounding_mode == float_round_down) {
                    zSign = 1;
                } else {
                    zSign = 0;
                }
                return packFloat32(zSign ^ signflip, 0, 0);
            }
            /* Exact zero plus a denorm */
            if (status->flush_to_zero) {
                float_raise(float_flag_output_denormal, status);
                return packFloat32(cSign ^ signflip, 0, 0);
            }
        }
        /* Zero plus something non-zero : just return the something */
        if (flags & float_muladd_halve_result) {
            if (cExp == 0) {
                normalizeFloat32Subnormal(cSig, &cExp, &cSig);
            }
            /* Subtract one to halve, and one again because roundAndPackFloat32
             * wants one less than the true exponent.
             */
            cExp -= 2;
            cSig = (cSig | 0x00800000) << 7;
            return roundAndPackFloat32(cSign ^ signflip, cExp, cSig, status);
        }
        return packFloat32(cSign ^ signflip, cExp, cSig);
    }

    if (aExp == 0) {
        normalizeFloat32Subnormal(aSig, &aExp, &aSig);
    }
    if (bExp == 0) {
        normalizeFloat32Subnormal(bSig, &bExp, &bSig);
    }

    /* Calculate the actual result a * b + c */

    /* Multiply first; this is easy. */
    /* NB: we subtract 0x7e where float32_mul() subtracts 0x7f
     * because we want the true exponent, not the "one-less-than"
     * flavour that roundAndPackFloat32() takes.
     */
    pExp = aExp + bExp - 0x7e;
    aSig = (aSig | 0x00800000) << 7;
    bSig = (bSig | 0x00800000) << 8;
    pSig64 = (uint64_t)aSig * bSig;
    if ((int64_t)(pSig64 << 1) >= 0) {
        pSig64 <<= 1;
        pExp--;
    }

    zSign = pSign ^ signflip;

    /* Now pSig64 is the significand of the multiply, with the explicit bit in
     * position 62.
     */
    if (cExp == 0) {
        if (!cSig) {
            /* Throw out the special case of c being an exact zero now */
            shift64RightJamming(pSig64, 32, &pSig64);
            pSig = pSig64;
            if (flags & float_muladd_halve_result) {
                pExp--;
            }
            return roundAndPackFloat32(zSign, pExp - 1,
                                       pSig, status);
        }
        normalizeFloat32Subnormal(cSig, &cExp, &cSig);
    }

    cSig64 = (uint64_t)cSig << (62 - 23);
    cSig64 |= LIT64(0x4000000000000000);
    expDiff = pExp - cExp;

    if (pSign == cSign) {
        /* Addition */
        if (expDiff > 0) {
            /* scale c to match p */
            shift64RightJamming(cSig64, expDiff, &cSig64);
            zExp = pExp;
        } else if (expDiff < 0) {
            /* scale p to match c */
            shift64RightJamming(pSig64, -expDiff, &pSig64);
            zExp = cExp;
        } else {
            /* no scaling needed */
            zExp = cExp;
        }
        /* Add significands and make sure explicit bit ends up in posn 62 */
        zSig64 = pSig64 + cSig64;
        if ((int64_t)zSig64 < 0) {
            shift64RightJamming(zSig64, 1, &zSig64);
        } else {
            zExp--;
        }
    } else {
        /* Subtraction */
        if (expDiff > 0) {
            shift64RightJamming(cSig64, expDiff, &cSig64);
            zSig64 = pSig64 - cSig64;
            zExp = pExp;
        } else if (expDiff < 0) {
            shift64RightJamming(pSig64, -expDiff, &pSig64);
            zSig64 = cSig64 - pSig64;
            zExp = cExp;
            zSign ^= 1;
        } else {
            zExp = pExp;
            if (cSig64 < pSig64) {
                zSig64 = pSig64 - cSig64;
            } else if (pSig64 < cSig64) {
                zSig64 = cSig64 - pSig64;
                zSign ^= 1;
            } else {
                /* Exact zero */
                zSign = signflip;
                if (status->float_rounding_mode == float_round_down) {
                    zSign ^= 1;
                }
                return packFloat32(zSign, 0, 0);
            }
        }
        --zExp;
        /* Normalize to put the explicit bit back into bit 62. */
        shiftcount = countLeadingZeros64(zSig64) - 1;
        zSig64 <<= shiftcount;
        zExp -= shiftcount;
    }
    if (flags & float_muladd_halve_result) {
        zExp--;
    }

    shift64RightJamming(zSig64, 32, &zSig64);
    return roundAndPackFloat32(zSign, zExp, zSig64, status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x11570
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x11570
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x11570
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x115f0
movl %eax, -0x5c(%rbp)
movl -0x8(%rbp), %edi
callq 0x115d0
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %edi
callq 0x12810
movb %al, -0x21(%rbp)
movl -0xc(%rbp), %edi
callq 0x115f0
movl %eax, -0x60(%rbp)
movl -0xc(%rbp), %edi
callq 0x115d0
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0x12810
movb %al, -0x22(%rbp)
movl -0x10(%rbp), %edi
callq 0x115f0
movl %eax, -0x64(%rbp)
movl -0x10(%rbp), %edi
callq 0x115d0
movq %rax, -0x40(%rbp)
movl -0x10(%rbp), %edi
callq 0x12810
movb %al, -0x23(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x14e13
cmpl $0x0, -0x5c(%rbp)
jne 0x14e13
cmpq $0xff, -0x38(%rbp)
jne 0x14e13
movb $0x1, %al
cmpl $0x0, -0x60(%rbp)
movb %al, -0x8b(%rbp)
je 0x14e5b
xorl %eax, %eax
cmpq $0xff, -0x30(%rbp)
movb %al, -0x8c(%rbp)
jne 0x14e4f
xorl %eax, %eax
cmpl $0x0, -0x5c(%rbp)
movb %al, -0x8c(%rbp)
jne 0x14e4f
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x8c(%rbp)
jne 0x14e4f
cmpl $0x0, -0x60(%rbp)
sete %al
movb %al, -0x8c(%rbp)
movb -0x8c(%rbp), %al
movb %al, -0x8b(%rbp)
movb -0x8b(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x8a(%rbp)
cmpq $0xff, -0x30(%rbp)
jne 0x14e7c
cmpl $0x0, -0x5c(%rbp)
jne 0x14e9c
cmpq $0xff, -0x38(%rbp)
jne 0x14e8c
cmpl $0x0, -0x60(%rbp)
jne 0x14e9c
cmpq $0xff, -0x40(%rbp)
jne 0x14ebf
cmpl $0x0, -0x64(%rbp)
je 0x14ebf
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movb -0x8a(%rbp), %al
movq -0x20(%rbp), %r8
movzbl %al, %ecx
callq 0x154c0
movl %eax, -0x4(%rbp)
jmp 0x154a5
cmpb $0x0, -0x8a(%rbp)
je 0x14ee2
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x7fc00000, -0x4(%rbp) # imm = 0x7FC00000
jmp 0x154a5
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x14ef7
movzbl -0x23(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x23(%rbp)
movl -0x14(%rbp), %edx
andl $0x4, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0x89(%rbp)
movzbl -0x21(%rbp), %eax
movzbl -0x22(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0x67(%rbp)
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x14f32
movzbl -0x67(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x67(%rbp)
movb $0x1, %al
cmpq $0xff, -0x30(%rbp)
movb %al, -0x8d(%rbp)
je 0x14f55
cmpq $0xff, -0x38(%rbp)
sete %al
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x65(%rbp)
movq -0x30(%rbp), %rcx
movl -0x5c(%rbp), %eax
orq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x8e(%rbp)
je 0x14f92
movq -0x38(%rbp), %rax
movl -0x60(%rbp), %ecx
orq %rcx, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x8e(%rbp)
movb -0x8e(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x66(%rbp)
cmpq $0xff, -0x40(%rbp)
jne 0x15000
movzbl -0x65(%rbp), %eax
cmpl $0x0, %eax
je 0x14fdc
movzbl -0x67(%rbp), %eax
movzbl -0x23(%rbp), %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x14fdc
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movl $0x7fc00000, -0x4(%rbp) # imm = 0x7FC00000
jmp 0x154a5
movzbl -0x23(%rbp), %eax
movzbl -0x89(%rbp), %ecx
xorl %ecx, %eax
movl $0xff, %esi
xorl %edx, %edx
movzbl %al, %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x154a5
cmpb $0x0, -0x65(%rbp)
je 0x1502a
movzbl -0x67(%rbp), %eax
movzbl -0x89(%rbp), %ecx
xorl %ecx, %eax
movl $0xff, %esi
xorl %edx, %edx
movzbl %al, %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x154a5
cmpb $0x0, -0x66(%rbp)
je 0x1515a
cmpq $0x0, -0x40(%rbp)
jne 0x150d2
cmpl $0x0, -0x64(%rbp)
jne 0x15095
movzbl -0x67(%rbp), %eax
movzbl -0x23(%rbp), %ecx
cmpl %ecx, %eax
jne 0x15059
movb -0x67(%rbp), %al
movb %al, -0x24(%rbp)
jmp 0x15072
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x1, %eax
jne 0x1506c
movb $0x1, -0x24(%rbp)
jmp 0x15070
movb $0x0, -0x24(%rbp)
jmp 0x15072
movzbl -0x24(%rbp), %eax
movzbl -0x89(%rbp), %ecx
xorl %ecx, %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
movzbl %al, %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x154a5
movq -0x20(%rbp), %rax
cmpb $0x0, 0x4(%rax)
je 0x150d0
movq -0x20(%rbp), %rsi
movl $0xffffff80, %edi       # imm = 0xFFFFFF80
callq 0x11080
movzbl -0x23(%rbp), %eax
movzbl -0x89(%rbp), %ecx
xorl %ecx, %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
movzbl %al, %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x154a5
jmp 0x150d2
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x15136
cmpq $0x0, -0x40(%rbp)
jne 0x150f4
movl -0x64(%rbp), %edi
leaq -0x40(%rbp), %rsi
leaq -0x64(%rbp), %rdx
callq 0x135b0
movq -0x40(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x40(%rbp)
movl -0x64(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
shll $0x7, %eax
movl %eax, -0x64(%rbp)
movzbl -0x23(%rbp), %eax
movzbl -0x89(%rbp), %ecx
xorl %ecx, %eax
movq -0x40(%rbp), %rsi
movl -0x64(%rbp), %edx
movq -0x20(%rbp), %rcx
movzbl %al, %edi
callq 0x11cb0
movl %eax, -0x4(%rbp)
jmp 0x154a5
movzbl -0x23(%rbp), %eax
movzbl -0x89(%rbp), %ecx
xorl %ecx, %eax
movq -0x40(%rbp), %rsi
movl -0x64(%rbp), %edx
movzbl %al, %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x154a5
cmpq $0x0, -0x30(%rbp)
jne 0x15171
movl -0x5c(%rbp), %edi
leaq -0x30(%rbp), %rsi
leaq -0x5c(%rbp), %rdx
callq 0x135b0
cmpq $0x0, -0x38(%rbp)
jne 0x15188
movl -0x60(%rbp), %edi
leaq -0x38(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x135b0
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
subq $0x7e, %rax
movq %rax, -0x48(%rbp)
movl -0x5c(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
shll $0x7, %eax
movl %eax, -0x5c(%rbp)
movl -0x60(%rbp), %eax
orl $0x800000, %eax         # imm = 0x800000
shll $0x8, %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %eax
movl -0x60(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
jl 0x151e6
movq -0x70(%rbp), %rax
shlq %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
movzbl -0x67(%rbp), %eax
movzbl -0x89(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0x24(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x1526b
cmpl $0x0, -0x64(%rbp)
jne 0x1525b
movq -0x70(%rbp), %rdi
movl $0x20, %esi
leaq -0x70(%rbp), %rdx
callq 0x11c20
movq -0x70(%rbp), %rax
movl %eax, -0x84(%rbp)
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x15236
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
movb -0x24(%rbp), %al
movq -0x48(%rbp), %rsi
subq $0x1, %rsi
movl -0x84(%rbp), %edx
movq -0x20(%rbp), %rcx
movzbl %al, %edi
callq 0x11cb0
movl %eax, -0x4(%rbp)
jmp 0x154a5
movl -0x64(%rbp), %edi
leaq -0x40(%rbp), %rsi
leaq -0x64(%rbp), %rdx
callq 0x135b0
movl -0x64(%rbp), %eax
shlq $0x27, %rax
movq %rax, -0x78(%rbp)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
orq -0x78(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x48(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movzbl -0x67(%rbp), %eax
movzbl -0x23(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1532e
cmpq $0x0, -0x58(%rbp)
jle 0x152c6
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x11c20
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x152f6
cmpq $0x0, -0x58(%rbp)
jge 0x152ec
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
subq -0x58(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x11c20
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x152f4
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x152f6
movq -0x70(%rbp), %rax
addq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jge 0x1531d
movq -0x80(%rbp), %rdi
movl $0x1, %esi
leaq -0x80(%rbp), %rdx
callq 0x11c20
jmp 0x15329
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x15460
cmpq $0x0, -0x58(%rbp)
jle 0x1535f
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x11c20
movq -0x70(%rbp), %rax
subq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x1541a
cmpq $0x0, -0x58(%rbp)
jge 0x1539b
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
subq -0x58(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x11c20
movq -0x78(%rbp), %rax
subq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movzbl -0x24(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x24(%rbp)
jmp 0x15418
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x70(%rbp), %rax
jae 0x153bb
movq -0x70(%rbp), %rax
subq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x15416
movq -0x70(%rbp), %rax
cmpq -0x78(%rbp), %rax
jae 0x153dd
movq -0x78(%rbp), %rax
subq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
movzbl -0x24(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x24(%rbp)
jmp 0x15414
movb -0x89(%rbp), %al
movb %al, -0x24(%rbp)
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x1, %eax
jne 0x153fd
movzbl -0x24(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x24(%rbp)
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movzbl -0x24(%rbp), %edi
callq 0x11750
movl %eax, -0x4(%rbp)
jmp 0x154a5
jmp 0x15416
jmp 0x15418
jmp 0x1541a
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x80(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0x1, %eax
movl %eax, -0x88(%rbp)
movl -0x88(%rbp), %ecx
movq -0x80(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x80(%rbp)
movslq -0x88(%rbp), %rcx
movq -0x50(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x15477
movq -0x50(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x80(%rbp), %rdi
movl $0x20, %esi
leaq -0x80(%rbp), %rdx
callq 0x11c20
movb -0x24(%rbp), %al
movq -0x50(%rbp), %rsi
movq -0x80(%rbp), %rcx
movl %ecx, %edx
movq -0x20(%rbp), %rcx
movzbl %al, %edi
callq 0x11cb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)