let is_not_equal = x.next().map_or(true, |&xi| {

            let xor = xi ^ yi;

            xor != 0 && xor != 0x20

        });

pub fn starts_with_uncased<'a, 'b, Iter1, Iter2>(mut x: Iter1, mut y: Iter2) -> bool

where

    Iter1: Iterator<Item = &'a u8>,

    Iter2: Iterator<Item = &'b u8>,

{

    // We use a faster optimization here for ASCII letters, which NaN

    // and infinite strings **must** be. [A-Z] is 0x41-0x5A, while

    // [a-z] is 0x61-0x7A. Therefore, the xor must be 0 or 32 if they

    // are case-insensitive equal, but only if at least 1 of the inputs

    // is an ASCII letter.

    loop {

        let yi = y.next();

        if yi.is_none() {

            return true;

        }

        let yi = *yi.unwrap();

        let is_not_equal = x.next().map_or(true, |&xi| {

            let xor = xi ^ yi;

            xor != 0 && xor != 0x20

        });

        if is_not_equal {

            return false;

        }

    }

}

pub fn round<F, Cb>(fp: &mut ExtendedFloat80, cb: Cb)

where

    F: RawFloat,

    Cb: Fn(&mut ExtendedFloat80, i32),

{

    let fp_inf = ExtendedFloat80 {

        mant: 0,

        exp: F::INFINITE_POWER,

    };

    // Calculate our shift in significant digits.

    let mantissa_shift = 64 - F::MANTISSA_SIZE - 1;

    // Check for a denormal float, if after the shift the exponent is negative.

    if -fp.exp >= mantissa_shift {

        // Have a denormal float that isn't a literal 0.

        // The extra 1 is to adjust for the denormal float, which is

        // `1 - F::EXPONENT_BIAS`. This works as before, because our

        // old logic rounded to `F::DENORMAL_EXPONENT` (now 1), and then

        // checked if `exp == F::DENORMAL_EXPONENT` and no hidden mask

        // bit was set. Here, we handle that here, rather than later.

        //

        // This might round-down to 0, but shift will be at **max** 65,

        // for halfway cases rounding towards 0.

        let shift = -fp.exp + 1;

        debug_assert!(shift <= 65);

        cb(fp, shift.min(64));

        // Check for round-up: if rounding-nearest carried us to the hidden bit.

        fp.exp = (fp.mant >= F::HIDDEN_BIT_MASK.as_u64()) as i32;

        return;

    }

    // The float is normal, round to the hidden bit.

    cb(fp, mantissa_shift);

    // Check if we carried, and if so, shift the bit to the hidden bit.

    let carry_mask = F::CARRY_MASK.as_u64();

    if fp.mant & carry_mask == carry_mask {

        fp.mant >>= 1;

        fp.exp += 1;

    }

    // Handle if we carried and check for overflow again.

    if fp.exp >= F::INFINITE_POWER {

        // Exponent is above largest normal value, must be infinite.

        *fp = fp_inf;

        return;

    }

    // Remove the hidden bit.

    fp.mant &= F::MANTISSA_MASK.as_u64();

}

pub fn round<F, Cb>(fp: &mut ExtendedFloat80, cb: Cb)

where

    F: RawFloat,

    Cb: Fn(&mut ExtendedFloat80, i32),

{

    let fp_inf = ExtendedFloat80 {

        mant: 0,

        exp: F::INFINITE_POWER,

    };

    // Calculate our shift in significant digits.

    let mantissa_shift = 64 - F::MANTISSA_SIZE - 1;

    // Check for a denormal float, if after the shift the exponent is negative.

    if -fp.exp >= mantissa_shift {

        // Have a denormal float that isn't a literal 0.

        // The extra 1 is to adjust for the denormal float, which is

        // `1 - F::EXPONENT_BIAS`. This works as before, because our

        // old logic rounded to `F::DENORMAL_EXPONENT` (now 1), and then

        // checked if `exp == F::DENORMAL_EXPONENT` and no hidden mask

        // bit was set. Here, we handle that here, rather than later.

        //

        // This might round-down to 0, but shift will be at **max** 65,

        // for halfway cases rounding towards 0.

        let shift = -fp.exp + 1;

        debug_assert!(shift <= 65);

        cb(fp, shift.min(64));

        // Check for round-up: if rounding-nearest carried us to the hidden bit.

        fp.exp = (fp.mant >= F::HIDDEN_BIT_MASK.as_u64()) as i32;

        return;

    }

    // The float is normal, round to the hidden bit.

    cb(fp, mantissa_shift);

    // Check if we carried, and if so, shift the bit to the hidden bit.

    let carry_mask = F::CARRY_MASK.as_u64();

    if fp.mant & carry_mask == carry_mask {

        fp.mant >>= 1;

        fp.exp += 1;

    }

    // Handle if we carried and check for overflow again.

    if fp.exp >= F::INFINITE_POWER {

        // Exponent is above largest normal value, must be infinite.

        *fp = fp_inf;

        return;

    }

    // Remove the hidden bit.

    fp.mant &= F::MANTISSA_MASK.as_u64();

}

pub fn round<F, Cb>(fp: &mut ExtendedFloat80, cb: Cb)

where

    F: RawFloat,

    Cb: Fn(&mut ExtendedFloat80, i32),

{

    let fp_inf = ExtendedFloat80 {

        mant: 0,

        exp: F::INFINITE_POWER,

    };

    // Calculate our shift in significant digits.

    let mantissa_shift = 64 - F::MANTISSA_SIZE - 1;

    // Check for a denormal float, if after the shift the exponent is negative.

    if -fp.exp >= mantissa_shift {

        // Have a denormal float that isn't a literal 0.

        // The extra 1 is to adjust for the denormal float, which is

        // `1 - F::EXPONENT_BIAS`. This works as before, because our

        // old logic rounded to `F::DENORMAL_EXPONENT` (now 1), and then

        // checked if `exp == F::DENORMAL_EXPONENT` and no hidden mask

        // bit was set. Here, we handle that here, rather than later.

        //

        // This might round-down to 0, but shift will be at **max** 65,

        // for halfway cases rounding towards 0.

        let shift = -fp.exp + 1;

        debug_assert!(shift <= 65);

        cb(fp, shift.min(64));

        // Check for round-up: if rounding-nearest carried us to the hidden bit.

        fp.exp = (fp.mant >= F::HIDDEN_BIT_MASK.as_u64()) as i32;

        return;

    }

    // The float is normal, round to the hidden bit.

    cb(fp, mantissa_shift);

    // Check if we carried, and if so, shift the bit to the hidden bit.

    let carry_mask = F::CARRY_MASK.as_u64();

    if fp.mant & carry_mask == carry_mask {

        fp.mant >>= 1;

        fp.exp += 1;

    }

    // Handle if we carried and check for overflow again.

    if fp.exp >= F::INFINITE_POWER {

        // Exponent is above largest normal value, must be infinite.

        *fp = fp_inf;

        return;

    }

    // Remove the hidden bit.

    fp.mant &= F::MANTISSA_MASK.as_u64();

}

pub fn round_nearest_tie_even<Cb>(fp: &mut ExtendedFloat80, shift: i32, cb: Cb)

where

    // `is_odd`, `is_halfway`, `is_above`

    Cb: Fn(bool, bool, bool) -> bool,

{

    // Ensure we've already handled denormal values that underflow.

    debug_assert!(shift <= 64);

    // Extract the truncated bits using mask.

    // Calculate if the value of the truncated bits are either above

    // the mid-way point, or equal to it.

    //

    // For example, for 4 truncated bytes, the mask would be 0b1111

    // and the midway point would be 0b1000.

    let mask = lower_n_mask(shift as u64);

    let halfway = lower_n_halfway(shift as u64);

    let truncated_bits = fp.mant & mask;

    let is_above = truncated_bits > halfway;

    let is_halfway = truncated_bits == halfway;

    // Bit shift so the leading bit is in the hidden bit.

    // This optimizes pretty well:

    //  ```text

    //   mov     ecx, esi

    //   shr     rdi, cl

    //   xor     eax, eax

    //   cmp     esi, 64

    //   cmovne  rax, rdi

    //   ret

    //  ```

    fp.mant = match shift == 64 {

        true => 0,

        false => fp.mant >> shift,

    };

    fp.exp += shift;

    // Extract the last bit after shifting (and determine if it is odd).

    let is_odd = fp.mant & 1 == 1;

    // Calculate if we need to roundup.

    // We need to roundup if we are above halfway, or if we are odd

    // and at half-way (need to tie-to-even). Avoid the branch here.

    fp.mant += cb(is_odd, is_halfway, is_above) as u64;

}

pub fn round_nearest_tie_even<Cb>(fp: &mut ExtendedFloat80, shift: i32, cb: Cb)

where

    // `is_odd`, `is_halfway`, `is_above`

    Cb: Fn(bool, bool, bool) -> bool,

{

    // Ensure we've already handled denormal values that underflow.

    debug_assert!(shift <= 64);

    // Extract the truncated bits using mask.

    // Calculate if the value of the truncated bits are either above

    // the mid-way point, or equal to it.

    //

    // For example, for 4 truncated bytes, the mask would be 0b1111

    // and the midway point would be 0b1000.

    let mask = lower_n_mask(shift as u64);

    let halfway = lower_n_halfway(shift as u64);

    let truncated_bits = fp.mant & mask;

    let is_above = truncated_bits > halfway;

    let is_halfway = truncated_bits == halfway;

    // Bit shift so the leading bit is in the hidden bit.

    // This optimizes pretty well:

    //  ```text

    //   mov     ecx, esi

    //   shr     rdi, cl

    //   xor     eax, eax

    //   cmp     esi, 64

    //   cmovne  rax, rdi

    //   ret

    //  ```

    fp.mant = match shift == 64 {

        true => 0,

        false => fp.mant >> shift,

    };

    fp.exp += shift;

    // Extract the last bit after shifting (and determine if it is odd).

    let is_odd = fp.mant & 1 == 1;

    // Calculate if we need to roundup.

    // We need to roundup if we are above halfway, or if we are odd

    // and at half-way (need to tie-to-even). Avoid the branch here.

    fp.mant += cb(is_odd, is_halfway, is_above) as u64;

}