use std::cmp::Ordering;

        let j: *mut IDedName = {

        let mut j: *mut IDedName = {

        while i < threshold {

        'sieve: loop {

            i = unsafe { comparator.partition(i, j, pivot).await? };

            let pivot = unsafe { comparator.partition(i, j, pivot).await? };
            match pivot.cmp(&threshold) {
                Ordering::Less => {
                    i = unsafe { pivot.offset(1) };
                }
                Ordering::Equal => {
                    break 'sieve;
                }
                Ordering::Greater => {
                    j = pivot;
                }
            }

        unsafe {
            shortlist.truncate(1 + i.offset_from(&shortlist[0]) as usize)
        };

        shortlist.truncate(count as usize);

        use std::cmp::Ordering::*;

        use Ordering::*;

    ) -> DynResult<std::cmp::Ordering> {

    ) -> DynResult<Ordering> {

                                break (std::cmp::Ordering::Greater, a.1, b.1);

                                break (Ordering::Greater, a.1, b.1);

                                break (std::cmp::Ordering::Less, b.1, a.1);

                                break (Ordering::Less, b.1, a.1);