// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/softfloat.c
// Function: float64_muladd
float64 float64_muladd(float64 a, float64 b, float64 c, int flags,
                       float_status *status)
{
    flag aSign, bSign, cSign, zSign;
    int_fast16_t aExp, bExp, cExp, pExp, zExp, expDiff;
    uint64_t aSig, bSig, cSig;
    flag pInf, pZero, pSign;
    uint64_t pSig0, pSig1, cSig0, cSig1, zSig0, zSig1;
    int shiftcount;
    flag signflip, infzero;

    a = float64_squash_input_denormal(a, status);
    b = float64_squash_input_denormal(b, status);
    c = float64_squash_input_denormal(c, status);
    aSig = extractFloat64Frac(a);
    aExp = extractFloat64Exp(a);
    aSign = extractFloat64Sign(a);
    bSig = extractFloat64Frac(b);
    bExp = extractFloat64Exp(b);
    bSign = extractFloat64Sign(b);
    cSig = extractFloat64Frac(c);
    cExp = extractFloat64Exp(c);
    cSign = extractFloat64Sign(c);

    infzero = ((aExp == 0 && aSig == 0 && bExp == 0x7ff && bSig == 0) ||
               (aExp == 0x7ff && 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 == 0x7ff) && aSig) ||
        ((bExp == 0x7ff) && bSig) ||
        ((cExp == 0x7ff) && cSig)) {
        return propagateFloat64MulAddNaN(a, b, c, infzero, status);
    }

    if (infzero) {
        float_raise(float_flag_invalid, status);
        return float64_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 == 0x7ff) || (bExp == 0x7ff);
    pZero = ((aExp | aSig) == 0) || ((bExp | bSig) == 0);

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

    if (pInf) {
        return packFloat64(pSign ^ signflip, 0x7ff, 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 packFloat64(zSign ^ signflip, 0, 0);
            }
            /* Exact zero plus a denorm */
            if (status->flush_to_zero) {
                float_raise(float_flag_output_denormal, status);
                return packFloat64(cSign ^ signflip, 0, 0);
            }
        }
        /* Zero plus something non-zero : just return the something */
        if (flags & float_muladd_halve_result) {
            if (cExp == 0) {
                normalizeFloat64Subnormal(cSig, &cExp, &cSig);
            }
            /* Subtract one to halve, and one again because roundAndPackFloat64
             * wants one less than the true exponent.
             */
            cExp -= 2;
            cSig = (cSig | 0x0010000000000000ULL) << 10;
            return roundAndPackFloat64(cSign ^ signflip, cExp, cSig, status);
        }
        return packFloat64(cSign ^ signflip, cExp, cSig);
    }

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

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

    /* Multiply first; this is easy. */
    /* NB: we subtract 0x3fe where float64_mul() subtracts 0x3ff
     * because we want the true exponent, not the "one-less-than"
     * flavour that roundAndPackFloat64() takes.
     */
    pExp = aExp + bExp - 0x3fe;
    aSig = (aSig | LIT64(0x0010000000000000))<<10;
    bSig = (bSig | LIT64(0x0010000000000000))<<11;
    mul64To128(aSig, bSig, &pSig0, &pSig1);
    if ((int64_t)(pSig0 << 1) >= 0) {
        shortShift128Left(pSig0, pSig1, 1, &pSig0, &pSig1);
        pExp--;
    }

    zSign = pSign ^ signflip;

    /* Now [pSig0:pSig1] is the significand of the multiply, with the explicit
     * bit in position 126.
     */
    if (cExp == 0) {
        if (!cSig) {
            /* Throw out the special case of c being an exact zero now */
            shift128RightJamming(pSig0, pSig1, 64, &pSig0, &pSig1);
            if (flags & float_muladd_halve_result) {
                pExp--;
            }
            return roundAndPackFloat64(zSign, pExp - 1,
                                       pSig1, status);
        }
        normalizeFloat64Subnormal(cSig, &cExp, &cSig);
    }

    /* Shift cSig and add the explicit bit so [cSig0:cSig1] is the
     * significand of the addend, with the explicit bit in position 126.
     */
    cSig0 = cSig << (126 - 64 - 52);
    cSig1 = 0;
    cSig0 |= LIT64(0x4000000000000000);
    expDiff = pExp - cExp;

    if (pSign == cSign) {
        /* Addition */
        if (expDiff > 0) {
            /* scale c to match p */
            shift128RightJamming(cSig0, cSig1, expDiff, &cSig0, &cSig1);
            zExp = pExp;
        } else if (expDiff < 0) {
            /* scale p to match c */
            shift128RightJamming(pSig0, pSig1, -expDiff, &pSig0, &pSig1);
            zExp = cExp;
        } else {
            /* no scaling needed */
            zExp = cExp;
        }
        /* Add significands and make sure explicit bit ends up in posn 126 */
        add128(pSig0, pSig1, cSig0, cSig1, &zSig0, &zSig1);
        if ((int64_t)zSig0 < 0) {
            shift128RightJamming(zSig0, zSig1, 1, &zSig0, &zSig1);
        } else {
            zExp--;
        }
        shift128RightJamming(zSig0, zSig1, 64, &zSig0, &zSig1);
        if (flags & float_muladd_halve_result) {
            zExp--;
        }
        return roundAndPackFloat64(zSign, zExp, zSig1, status);
    } else {
        /* Subtraction */
        if (expDiff > 0) {
            shift128RightJamming(cSig0, cSig1, expDiff, &cSig0, &cSig1);
            sub128(pSig0, pSig1, cSig0, cSig1, &zSig0, &zSig1);
            zExp = pExp;
        } else if (expDiff < 0) {
            shift128RightJamming(pSig0, pSig1, -expDiff, &pSig0, &pSig1);
            sub128(cSig0, cSig1, pSig0, pSig1, &zSig0, &zSig1);
            zExp = cExp;
            zSign ^= 1;
        } else {
            zExp = pExp;
            if (lt128(cSig0, cSig1, pSig0, pSig1)) {
                sub128(pSig0, pSig1, cSig0, cSig1, &zSig0, &zSig1);
            } else if (lt128(pSig0, pSig1, cSig0, cSig1)) {
                sub128(cSig0, cSig1, pSig0, pSig1, &zSig0, &zSig1);
                zSign ^= 1;
            } else {
                /* Exact zero */
                zSign = signflip;
                if (status->float_rounding_mode == float_round_down) {
                    zSign ^= 1;
                }
                return packFloat64(zSign, 0, 0);
            }
        }
        --zExp;
        /* Do the equivalent of normalizeRoundAndPackFloat64() but
         * starting with the significand in a pair of uint64_t.
         */
        if (zSig0) {
            shiftcount = countLeadingZeros64(zSig0) - 1;
            shortShift128Left(zSig0, zSig1, shiftcount, &zSig0, &zSig1);
            if (zSig1) {
                zSig0 |= 1;
            }
            zExp -= shiftcount;
        } else {
            shiftcount = countLeadingZeros64(zSig1);
            if (shiftcount == 0) {
                zSig0 = (zSig1 >> 1) | (zSig1 & 1);
                zExp -= 63;
            } else {
                shiftcount--;
                zSig0 = zSig1 << shiftcount;
                zExp -= (shiftcount + 64);
            }
        }
        if (flags & float_muladd_halve_result) {
            zExp--;
        }
        return roundAndPackFloat64(zSign, zExp, zSig0, status);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11610
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11610
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11610
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x116a0
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11680
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x168f0
movb %al, -0x31(%rbp)
movq -0x18(%rbp), %rdi
callq 0x116a0
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11680
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x168f0
movb %al, -0x32(%rbp)
movq -0x20(%rbp), %rdi
callq 0x116a0
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11680
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x168f0
movb %al, -0x33(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x190fa
cmpq $0x0, -0x70(%rbp)
jne 0x190fa
cmpq $0x7ff, -0x48(%rbp)     # imm = 0x7FF
jne 0x190fa
movb $0x1, %al
cmpq $0x0, -0x78(%rbp)
movb %al, -0xbf(%rbp)
je 0x19144
xorl %eax, %eax
cmpq $0x7ff, -0x40(%rbp)     # imm = 0x7FF
movb %al, -0xc0(%rbp)
jne 0x19138
xorl %eax, %eax
cmpq $0x0, -0x70(%rbp)
movb %al, -0xc0(%rbp)
jne 0x19138
xorl %eax, %eax
cmpq $0x0, -0x48(%rbp)
movb %al, -0xc0(%rbp)
jne 0x19138
cmpq $0x0, -0x78(%rbp)
sete %al
movb %al, -0xc0(%rbp)
movb -0xc0(%rbp), %al
movb %al, -0xbf(%rbp)
movb -0xbf(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0xbe(%rbp)
cmpq $0x7ff, -0x40(%rbp)     # imm = 0x7FF
jne 0x19166
cmpq $0x0, -0x70(%rbp)
jne 0x19188
cmpq $0x7ff, -0x48(%rbp)     # imm = 0x7FF
jne 0x19177
cmpq $0x0, -0x78(%rbp)
jne 0x19188
cmpq $0x7ff, -0x50(%rbp)     # imm = 0x7FF
jne 0x191af
cmpq $0x0, -0x80(%rbp)
je 0x191af
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0xbe(%rbp), %al
movq -0x30(%rbp), %r8
movzbl %al, %ecx
callq 0x19ac0
movq %rax, -0x8(%rbp)
jmp 0x19aaf
cmpb $0x0, -0xbe(%rbp)
je 0x191d9
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, -0x8(%rbp)
jmp 0x19aaf
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x191ee
movzbl -0x33(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x33(%rbp)
movl -0x24(%rbp), %edx
andl $0x4, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0xbd(%rbp)
movzbl -0x31(%rbp), %eax
movzbl -0x32(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0x83(%rbp)
movl -0x24(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x19232
movzbl -0x83(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x83(%rbp)
movb $0x1, %al
cmpq $0x7ff, -0x40(%rbp)     # imm = 0x7FF
movb %al, -0xc1(%rbp)
je 0x19255
cmpq $0x7ff, -0x48(%rbp)     # imm = 0x7FF
sete %al
movb %al, -0xc1(%rbp)
movb -0xc1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x81(%rbp)
movq -0x40(%rbp), %rcx
orq -0x70(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0xc2(%rbp)
je 0x19291
movq -0x48(%rbp), %rax
orq -0x78(%rbp), %rax
cmpq $0x0, %rax
sete %al
movb %al, -0xc2(%rbp)
movb -0xc2(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x82(%rbp)
cmpq $0x7ff, -0x50(%rbp)     # imm = 0x7FF
jne 0x19312
movzbl -0x81(%rbp), %eax
cmpl $0x0, %eax
je 0x192eb
movzbl -0x83(%rbp), %eax
movzbl -0x33(%rbp), %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x192eb
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x11080
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, -0x8(%rbp)
jmp 0x19aaf
movzbl -0x33(%rbp), %eax
movzbl -0xbd(%rbp), %ecx
xorl %ecx, %eax
movl $0x7ff, %esi            # imm = 0x7FF
xorl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %edi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x19aaf
cmpb $0x0, -0x81(%rbp)
je 0x19345
movzbl -0x83(%rbp), %eax
movzbl -0xbd(%rbp), %ecx
xorl %ecx, %eax
movl $0x7ff, %esi            # imm = 0x7FF
xorl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %edi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x19aaf
cmpb $0x0, -0x82(%rbp)
je 0x19490
cmpq $0x0, -0x50(%rbp)
jne 0x193fb
cmpq $0x0, -0x80(%rbp)
jne 0x193bc
movzbl -0x83(%rbp), %eax
movzbl -0x33(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1937e
movb -0x83(%rbp), %al
movb %al, -0x34(%rbp)
jmp 0x19397
movq -0x30(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x1, %eax
jne 0x19391
movb $0x1, -0x34(%rbp)
jmp 0x19395
movb $0x0, -0x34(%rbp)
jmp 0x19397
movzbl -0x34(%rbp), %eax
movzbl -0xbd(%rbp), %ecx
xorl %ecx, %eax
xorl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %edi
movq %rdx, %rsi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x19aaf
movq -0x30(%rbp), %rax
cmpb $0x0, 0x4(%rax)
je 0x193f9
movq -0x30(%rbp), %rsi
movl $0xffffff80, %edi       # imm = 0xFFFFFF80
callq 0x11080
movzbl -0x33(%rbp), %eax
movzbl -0xbd(%rbp), %ecx
xorl %ecx, %eax
xorl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %edi
movq %rdx, %rsi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x19aaf
jmp 0x193fb
movl -0x24(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x1946a
cmpq $0x0, -0x50(%rbp)
jne 0x1941e
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x17a20
movq -0x50(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x50(%rbp)
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x80(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0x80(%rbp)
movzbl -0x33(%rbp), %eax
movzbl -0xbd(%rbp), %ecx
xorl %ecx, %eax
movq -0x50(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x30(%rbp), %rcx
movzbl %al, %edi
callq 0x12390
movq %rax, -0x8(%rbp)
jmp 0x19aaf
movzbl -0x33(%rbp), %eax
movzbl -0xbd(%rbp), %ecx
xorl %ecx, %eax
movq -0x50(%rbp), %rsi
movq -0x80(%rbp), %rdx
movzbl %al, %edi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x19aaf
cmpq $0x0, -0x40(%rbp)
jne 0x194a8
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x17a20
cmpq $0x0, -0x48(%rbp)
jne 0x194c0
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x17a20
movq -0x40(%rbp), %rax
addq -0x48(%rbp), %rax
subq $0x3fe, %rax            # imm = 0x3FE
movq %rax, -0x58(%rbp)
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x70(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0x70(%rbp)
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
orq -0x78(%rbp), %rax
shlq $0xb, %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x90(%rbp), %rdx
leaq -0x98(%rbp), %rcx
callq 0x18730
movq -0x90(%rbp), %rax
shlq %rax
cmpq $0x0, %rax
jl 0x1955b
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl $0x1, %edx
leaq -0x90(%rbp), %rcx
leaq -0x98(%rbp), %r8
callq 0x121c0
movq -0x58(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
movzbl -0x83(%rbp), %eax
movzbl -0xbd(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0x34(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x195f1
cmpq $0x0, -0x80(%rbp)
jne 0x195e0
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl $0x40, %edx
leaq -0x90(%rbp), %rcx
leaq -0x98(%rbp), %r8
callq 0x19c20
movl -0x24(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x195b9
movq -0x58(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
movb -0x34(%rbp), %al
movq -0x58(%rbp), %rsi
subq $0x1, %rsi
movq -0x98(%rbp), %rdx
movq -0x30(%rbp), %rcx
movzbl %al, %edi
callq 0x12390
movq %rax, -0x8(%rbp)
jmp 0x19aaf
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x17a20
movq -0x80(%rbp), %rax
shlq $0xa, %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0xa8(%rbp)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
orq -0xa0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x58(%rbp), %rax
subq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
movzbl -0x83(%rbp), %eax
movzbl -0x33(%rbp), %ecx
cmpl %ecx, %eax
jne 0x19789
cmpq $0x0, -0x68(%rbp)
jle 0x19678
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
leaq -0xa8(%rbp), %r8
callq 0x19c20
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x196bc
cmpq $0x0, -0x68(%rbp)
jge 0x196b2
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
subq -0x68(%rbp), %rdx
leaq -0x90(%rbp), %rcx
leaq -0x98(%rbp), %r8
callq 0x19c20
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x196ba
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x196bc
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
leaq -0xb0(%rbp), %r8
leaq -0xb8(%rbp), %r9
callq 0x18bd0
cmpq $0x0, -0xb0(%rbp)
jge 0x1971d
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movl $0x1, %edx
leaq -0xb0(%rbp), %rcx
leaq -0xb8(%rbp), %r8
callq 0x19c20
jmp 0x19729
movq -0x60(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x60(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movl $0x40, %edx
leaq -0xb0(%rbp), %rcx
leaq -0xb8(%rbp), %r8
callq 0x19c20
movl -0x24(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x19766
movq -0x60(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x60(%rbp)
movb -0x34(%rbp), %al
movq -0x60(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq -0x30(%rbp), %rcx
movzbl %al, %edi
callq 0x12390
movq %rax, -0x8(%rbp)
jmp 0x19aaf
cmpq $0x0, -0x68(%rbp)
jle 0x197f1
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
leaq -0xa8(%rbp), %r8
callq 0x19c20
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
leaq -0xb0(%rbp), %r8
leaq -0xb8(%rbp), %r9
callq 0x18b70
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x19967
cmpq $0x0, -0x68(%rbp)
jge 0x19867
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
subq -0x68(%rbp), %rdx
leaq -0x90(%rbp), %rcx
leaq -0x98(%rbp), %r8
callq 0x19c20
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rcx
leaq -0xb0(%rbp), %r8
leaq -0xb8(%rbp), %r9
callq 0x18b70
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movzbl -0x34(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x34(%rbp)
jmp 0x19965
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rcx
callq 0x19d70
cmpb $0x0, %al
je 0x198c8
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
leaq -0xb0(%rbp), %r8
leaq -0xb8(%rbp), %r9
callq 0x18b70
jmp 0x19963
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
callq 0x19d70
cmpb $0x0, %al
je 0x19928
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rcx
leaq -0xb0(%rbp), %r8
leaq -0xb8(%rbp), %r9
callq 0x18b70
movzbl -0x34(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x34(%rbp)
jmp 0x19961
movb -0xbd(%rbp), %al
movb %al, -0x34(%rbp)
movq -0x30(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x1, %eax
jne 0x19948
movzbl -0x34(%rbp), %eax
xorl $0x1, %eax
movb %al, -0x34(%rbp)
xorl %eax, %eax
movl %eax, %edx
movzbl -0x34(%rbp), %edi
movq %rdx, %rsi
callq 0x118b0
movq %rax, -0x8(%rbp)
jmp 0x19aaf
jmp 0x19963
jmp 0x19965
jmp 0x19967
movq -0x60(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0xb0(%rbp)
je 0x199f0
movq -0xb0(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
subl $0x1, %eax
movl %eax, -0xbc(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movslq -0xbc(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
leaq -0xb8(%rbp), %r8
callq 0x121c0
cmpq $0x0, -0xb8(%rbp)
je 0x199d9
movq -0xb0(%rbp), %rax
orq $0x1, %rax
movq %rax, -0xb0(%rbp)
movslq -0xbc(%rbp), %rcx
movq -0x60(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0x19a7a
movq -0xb8(%rbp), %rdi
callq 0x11bf0
movsbl %al, %eax
movl %eax, -0xbc(%rbp)
cmpl $0x0, -0xbc(%rbp)
jne 0x19a3b
movq -0xb8(%rbp), %rax
shrq %rax
movq -0xb8(%rbp), %rcx
andq $0x1, %rcx
orq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x60(%rbp), %rax
subq $0x3f, %rax
movq %rax, -0x60(%rbp)
jmp 0x19a78
movl -0xbc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xbc(%rbp)
movq -0xb8(%rbp), %rax
movl -0xbc(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0xb0(%rbp)
movl -0xbc(%rbp), %eax
addl $0x40, %eax
movslq %eax, %rcx
movq -0x60(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0x19a7a
movl -0x24(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x19a91
movq -0x60(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x60(%rbp)
movb -0x34(%rbp), %al
movq -0x60(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0x30(%rbp), %rcx
movzbl %al, %edi
callq 0x12390
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)