atoi-hang.rs

// GOAL: Implements(?0: FromRadix10Checked)
trait FromRadix10Checked {}
impl<I> FromRadix10Checked for I where I: Zero, I: One, I: FromRadix10, I: CheckedMul, I: CheckedAdd, I: MaxNumDigits {}
trait MaxNumDigits {}
impl<I> MaxNumDigits for I where I: Bounded, I: Zero, I: DivAssign<Self>, I: Ord, I: Copy {}
trait Copy {}
impl<T> Copy for *mut T {}
impl<T> Copy for Discriminant<T> {}
impl<T> Copy for *const T {}
impl<K, V, Type> Copy for NodeRef<Immut, K, V, Type> where {error}, {error} {}
impl<T> Copy for Unique<T> {}
impl Copy for ! {}
impl<T> Copy for NonNull<T> {}
impl<T> Copy for &T {}
impl<Node, Type> Copy for Handle<Node, Type> where Node: Copy {}
trait Ord {}
impl Ord for Infallible {}
impl<T> Ord for Arc<T> where T: Ord {}
impl Ord for Components {}
impl<T> Ord for NonNull<T> {}
impl<T> Ord for Cell<T> where T: Ord, T: Copy {}
impl Ord for Ordering {}
impl Ord for Path {}
impl Ord for str {}
impl Ord for Ipv6Addr {}
impl Ord for () {}
impl<T> Ord for Vec<T> where T: Ord {}
impl<T> Ord for [T] where T: Ord {}
impl Ord for OsStr {}
impl<B> Ord for Cow<B> where B: Ord, B: ToOwned {}
impl Ord for CStr {}
impl Ord for PrefixComponent {}
impl<T> Ord for Rc<T> where T: Ord {}
impl Ord for PathBuf {}
impl Ord for Ipv4Addr {}
impl<T> Ord for LinkedList<T> where T: Ord {}
impl<A> Ord for &mut A where A: Ord {}
impl<T> Ord for RefCell<T> where T: Ord {}
impl<T> Ord for Reverse<T> where T: Ord {}
impl<T> Ord for *mut T {}
impl<T> Ord for *const T {}
impl Ord for OsString {}
impl Ord for ! {}
impl<A> Ord for &A where A: Ord {}
impl<K, V> Ord for BTreeMap<K, V> where K: Ord, V: Ord {}
impl<A> Ord for VecDeque<A> where A: Ord {}
impl Ord for bool {}
struct Discriminant<T>;
trait DivAssign<Rhs> {}
impl DivAssign<u32> for Duration {}
struct Unique<T>;
struct NonNull<T>;
struct Handle<Node, Type>;
struct Infallible;
struct Arc<T>;
struct Components;
trait ToOwned {
  type Owned;
}
impl ToOwned for str {
  type Owned = String;
}
impl ToOwned for CStr {
  type Owned = CString;
}
impl<T> ToOwned for T where T: Clone {
  type Owned = T;
}
impl<T> ToOwned for [T] where T: Clone {
  type Owned = Vec<T>;
}
impl ToOwned for Path {
  type Owned = PathBuf;
}
impl ToOwned for OsStr {
  type Owned = OsString;
}
struct Cell<T>;
struct Ordering;
struct Path;
struct Ipv6Addr;
struct Vec<T>;
struct OsStr;
struct CStr;
struct PrefixComponent;
struct Rc<T>;
struct PathBuf;
struct Ipv4Addr;
struct LinkedList<T>;
struct RefCell<T>;
struct Reverse<T>;
struct OsString;
struct BTreeMap<K, V>;
struct VecDeque<T>;
trait CheckedAdd {}
trait Clone {}
impl<A> Clone for Iter<A> {}
impl<B> Clone for Cow<B> where B: ToOwned {}
impl<I, U> Clone for Flatten<I> where I: Iterator, I: Clone, U: Iterator, U: Clone, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {}
impl<T> Clone for SymmetricDifference<T> {}
impl<T> Clone for Iter<T> {}
impl Clone for ! {}
impl Clone for Ipv6Addr {}
impl<K, V> Clone for Keys<K, V> {}
impl<T> Clone for ChunksExact<T> {}
impl<S> Clone for Hasher<S> where S: Sip {}
impl<T> Clone for NonNull<T> {}
impl<T> Clone for Chunks<T> {}
impl<T> Clone for Weak<T> {}
impl<Node, Type> Clone for Handle<Node, Type> where Node: Copy {}
impl<T, S> Clone for Intersection<T, S> {}
impl<T> Clone for *mut T {}
impl Clone for Box<Path> {}
impl Clone for Waker {}
impl<T> Clone for Difference<T> {}
impl<T> Clone for RChunks<T> {}
impl Clone for String {}
impl<K, V> Clone for Keys<K, V> {}
impl<K> Clone for Iter<K> {}
impl<T> Clone for Discriminant<T> {}
impl Clone for SocketAddrV4 {}
impl<T> Clone for Iter<T> {}
impl<H> Clone for BuildHasherDefault<H> {}
impl<K, V> Clone for Values<K, V> {}
impl<T> Clone for BinaryHeap<T> where T: Clone {}
impl Clone for BorrowRef {}
impl<T> Clone for Windows<T> {}
impl<T> Clone for Arc<T> {}
impl<T> Clone for VecDeque<T> where T: Clone {}
impl<K, V> Clone for Iter<K, V> {}
impl<T, E> Clone for Result<T, E> where T: Clone, E: Clone {}
impl<T> Clone for Sender<T> {}
impl<T> Clone for LinkedList<T> where T: Clone {}
impl<K, V> Clone for Values<K, V> {}
impl<T> Clone for Unique<T> {}
impl Clone for VaListImpl {}
impl<T, S> Clone for Union<T, S> {}
impl<K, V> Clone for BTreeMap<K, V> where K: Clone, V: Clone {}
impl<T> Clone for RefCell<T> where T: Clone {}
impl<T, S> Clone for SymmetricDifference<T, S> {}
impl Clone for Ipv4Addr {}
impl<T> Clone for Union<T> {}
impl<T> Clone for Vec<T> where T: Clone {}
impl Clone for Droppable {}
impl<T, P> Clone for Split<T, P> where P: Clone, P: FnMut<{unknown}> {}
impl<K, V> Clone for Range<K, V> {}
impl Clone for Infallible {}
impl<T> Clone for *const T {}
impl<T> Clone for Iter<T> {}
impl<K, V, Type> Clone for NodeRef<Immut, K, V, Type> where {error}, {error} {}
impl<T> Clone for MaybeUninit<T> where T: Copy {}
impl<T> Clone for RChunksExact<T> {}
impl<T> Clone for Iter<T> {}
impl Clone for SocketAddrV6 {}
impl<T> Clone for Intersection<T> {}
impl<T> Clone for Iter<T> {}
impl<T> Clone for IntoIter<T> where T: Clone {}
impl<T> Clone for SyncSender<T> {}
impl<T> Clone for &T {}
impl<T> Clone for Weak<T> {}
impl<T> Clone for Iter<T> {}
impl<T, S> Clone for Difference<T, S> {}
impl<T> Clone for Option<T> where T: Clone {}
impl<T> Clone for Cell<T> where T: Copy {}
impl Clone for Box<OsStr> {}
impl Clone for Box<CStr> {}
impl<T> Clone for Rc<T> {}
impl<T> Clone for Empty<T> {}
impl<I, U, F> Clone for FlatMap<I, U, F> where I: Clone, U: Clone, U: IntoIterator, F: Clone, <U as IntoIterator>::IntoIter: Clone {}
impl<T> Clone for Range<T> {}
impl<K, V> Clone for Iter<K, V> {}
struct Cow<B>;
struct Iter<A>;
impl<T> IntoIterator for &mut VecDeque<T> {
  type Item = &mut T;
  type IntoIter = IterMut<T>;
}
impl<T> IntoIterator for &LinkedList<T> {
  type Item = &T;
  type IntoIter = Iter<T>;
}
impl<K, V> IntoIterator for BTreeMap<K, V> {
  type Item = (K, V);
  type IntoIter = IntoIter<K, V>;
}
impl<T> IntoIterator for Vec<T> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<K, V> IntoIterator for &mut BTreeMap<K, V> where {error}, {error} {
  type Item = (&K, &mut V);
  type IntoIter = IterMut<K, V>;
}
impl<T, E> IntoIterator for &mut Result<T, E> {
  type Item = &mut T;
  type IntoIter = IterMut<T>;
}
impl<K, V, S> IntoIterator for &HashMap<K, V, S> {
  type Item = (&K, &V);
  type IntoIter = Iter<K, V>;
}
impl<I> IntoIterator for I where I: Iterator {
  type Item = {unknown};
  type IntoIter = I;
}
impl<T> IntoIterator for BinaryHeap<T> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &[T] {
  type Item = &T;
  type IntoIter = Iter<T>;
}
impl<T> IntoIterator for &mut [T] {
  type Item = &mut T;
  type IntoIter = IterMut<T>;
}
impl<K, V> IntoIterator for &BTreeMap<K, V> where {error}, {error} {
  type Item = (&K, &V);
  type IntoIter = Iter<K, V>;
}
impl IntoIterator for &Path {
  type Item = &OsStr;
  type IntoIter = Iter;
}
impl<T, E> IntoIterator for &Result<T, E> {
  type Item = &T;
  type IntoIter = Iter<T>;
}
impl<T, E> IntoIterator for Result<T, E> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &Option<T> {
  type Item = &T;
  type IntoIter = Iter<T>;
}
impl<T, S> IntoIterator for &HashSet<T, S> {
  type Item = &T;
  type IntoIter = Iter<T>;
}
impl<K, V, S> IntoIterator for &mut HashMap<K, V, S> {
  type Item = (&K, &mut V);
  type IntoIter = IterMut<K, V>;
}
impl<T> IntoIterator for Receiver<T> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &BinaryHeap<T> {
  type Item = &T;
  type IntoIter = Iter<T>;
}
impl<T> IntoIterator for BTreeSet<T> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &Receiver<T> {
  type Item = T;
  type IntoIter = Iter<T>;
}
impl<T> IntoIterator for VecDeque<T> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &mut Vec<T> {
  type Item = &mut T;
  type IntoIter = IterMut<T>;
}
impl<T> IntoIterator for &mut LinkedList<T> {
  type Item = &mut T;
  type IntoIter = IterMut<T>;
}
impl<T> IntoIterator for LinkedList<T> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &Vec<T> {
  type Item = &T;
  type IntoIter = Iter<T>;
}
impl IntoIterator for &PathBuf {
  type Item = &OsStr;
  type IntoIter = Iter;
}
impl<T> IntoIterator for &mut Option<T> {
  type Item = &mut T;
  type IntoIter = IterMut<T>;
}
impl<T> IntoIterator for Option<T> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<K, V, S> IntoIterator for HashMap<K, V, S> {
  type Item = (K, V);
  type IntoIter = IntoIter<K, V>;
}
impl<T, S> IntoIterator for HashSet<T, S> {
  type Item = T;
  type IntoIter = IntoIter<T>;
}
impl<T> IntoIterator for &BTreeSet<T> {
  type Item = &T;
  type IntoIter = Iter<T>;
}
impl<T> IntoIterator for &VecDeque<T> {
  type Item = &T;
  type IntoIter = Iter<T>;
}
trait Iterator {
  type Item;
}
impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator {
  type Item = ({unknown}, {unknown});
}
impl Iterator for EncodeUtf16 {
  type Item = u16;
}
impl<I> Iterator for Peekable<I> where I: Iterator {
  type Item = {unknown};
}
impl<T> Iterator for IntoIter<T> {
  type Item = T;
}
impl<K, V> Iterator for Iter<K, V> where {error}, {error} {
  type Item = (&K, &V);
}
impl<I> Iterator for Fuse<I> where I: FusedIterator {}
impl<T> Iterator for Once<T> {
  type Item = T;
}
impl Iterator for CharIndices {
  type Item = (usize, {unknown});
}
impl<K, V> Iterator for IntoIter<K, V> {
  type Item = (K, V);
}
impl<T> Iterator for Union<T> where T: Ord {
  type Item = &T;
}
impl<T> Iterator for RChunksExactMut<T> {
  type Item = &mut [T];
}
impl<T, F> Iterator for Successors<T, F> where F: FnMut<{unknown}> {
  type Item = T;
}
impl<I, U, F> Iterator for FlatMap<I, U, F> where I: Iterator, U: IntoIterator, F: FnMut<{unknown}> {
  type Item = {unknown};
}
impl<T> Iterator for Iter<T> {
  type Item = &T;
}
impl<T> Iterator for ChunksExactMut<T> {
  type Item = &mut [T];
}
impl Iterator for ErrorIter {
  type Item = &dyn Error + {error};
}
impl<T, S> Iterator for SymmetricDifference<T, S> where T: Eq, T: Hash, S: BuildHasher {
  type Item = &T;
}
impl<T, P> Iterator for Split<T, P> where P: FnMut<{unknown}> {
  type Item = &[T];
}
impl<B> Iterator for Split<B> where B: BufRead {
  type Item = Result<Vec<u8>, Error>;
}
impl Iterator for ToLowercase {
  type Item = char;
}
impl<A, F> Iterator for RepeatWith<F> where F: FnMut<{unknown}> {
  type Item = A;
}
impl Iterator for Iter {
  type Item = &OsStr;
}
impl<T, I> Iterator for GenericSplitN<I> where I: SplitIter, {error} {
  type Item = T;
}
impl<I, T> Iterator for Copied<I> where {error}, I: Iterator, <I as Iterator>::Item = &T, T: Copy {
  type Item = T;
}
impl<I> Iterator for Skip<I> where I: Iterator {
  type Item = <I as Iterator>::Item;
}
impl Iterator for SplitPaths {
  type Item = PathBuf;
}
impl Iterator for ArgsOs {
  type Item = OsString;
}
impl<T> Iterator for IntoIter<T> {
  type Item = T;
}
impl<T> Iterator for Drain<T> {
  type Item = T;
}
impl Iterator for EncodeWide {
  type Item = u16;
}
impl<I> Iterator for &mut I where I: Iterator {
  type Item = {unknown};
}
impl<K, V, I> Iterator for MergeIter<K, V, I> where K: Ord, I: Iterator, <I as Iterator>::Item = (K, V) {
  type Item = (K, V);
}
impl<T, P> Iterator for SplitMut<T, P> where P: FnMut<{unknown}> {
  type Item = &mut [T];
}
impl<I, T> Iterator for Cloned<I> where {error}, I: Iterator, <I as Iterator>::Item = &T, T: Clone {
  type Item = T;
}
impl<B, I, St, F> Iterator for Scan<I, St, F> where I: Iterator, F: FnMut<{unknown}> {
  type Item = B;
}
impl Iterator for Utf8LossyChunksIter {
  type Item = Utf8LossyChunk;
}
impl<I> Iterator for DecodeUtf16<I> where I: Iterator, <I as Iterator>::Item = u16 {
  type Item = Result<char, DecodeUtf16Error>;
}
impl Iterator for EscapeDefault {
  type Item = u8;
}
impl<K, V> Iterator for IterMut<K, V> where {error}, {error} {
  type Item = (&K, &mut V);
}
impl<K, V> Iterator for IterMut<K, V> {
  type Item = (&K, &mut V);
}
impl<T> Iterator for Iter<T> {
  type Item = &T;
}
impl Iterator for Incoming {
  type Item = Result<TcpStream, Error>;
}
impl<T> Iterator for IntoIter<T> {
  type Item = T;
}
impl<T> Iterator for Windows<T> {
  type Item = &[T];
}
impl<B, I, F> Iterator for Map<I, F> where I: Iterator, F: FnMut<{unknown}> {
  type Item = B;
}
impl<T, F> Iterator for DrainFilter<T, F> where F: FnMut<{unknown}> {
  type Item = T;
}
impl<T> Iterator for RChunksExact<T> {
  type Item = &[T];
}
impl<T> Iterator for Intersection<T> where T: Ord {
  type Item = &T;
}
impl<T> Iterator for Drain<T> {
  type Item = T;
}
impl Iterator for Drain {
  type Item = char;
}
impl Iterator for Vars {
  type Item = (String, String);
}
impl Iterator for SplitAsciiWhitespace {
  type Item = &str;
}
impl<T> Iterator for RChunksMut<T> {
  type Item = &mut [T];
}
impl<B> Iterator for Lines<B> where B: BufRead {
  type Item = Result<String, Error>;
}
impl Iterator for Args {
  type Item = String;
}
impl<T> Iterator for ChunksMut<T> {
  type Item = &mut [T];
}
impl<T> Iterator for TryIter<T> {
  type Item = T;
}
impl<T> Iterator for IntoIter<T> {
  type Item = T;
}
impl Iterator for Chars {
  type Item = {unknown};
}
impl<T> Iterator for Drain<T> {
  type Item = T;
}
impl<T, S> Iterator for Difference<T, S> where T: Eq, T: Hash, S: BuildHasher {
  type Item = &T;
}
impl<A> Iterator for IterMut<A> {
  type Item = &mut A;
}
impl<K, V> Iterator for ValuesMut<K, V> {
  type Item = &mut V;
}
impl Iterator for Components {
  type Item = Component;
}
impl<T> Iterator for IterMut<T> {
  type Item = &mut T;
}
impl<T, P> Iterator for RSplitMut<T, P> where P: FnMut<{unknown}> {
  type Item = &mut [T];
}
impl<I> Iterator for Take<I> where I: Iterator {
  type Item = <I as Iterator>::Item;
}
impl Iterator for EscapeDebug {
  type Item = char;
}
impl Iterator for EscapeDefault {
  type Item = char;
}
impl<A> Iterator for Repeat<A> where A: Clone {
  type Item = A;
}
impl<T> Iterator for IterMut<T> {
  type Item = &mut T;
}
impl<K, V> Iterator for Iter<K, V> {
  type Item = (&K, &V);
}
impl<K, V> Iterator for ValuesMut<K, V> {
  type Item = &mut V;
}
impl<T> Iterator for Range<T> {
  type Item = &T;
}
impl<I, P> Iterator for TakeWhile<I, P> where I: Iterator, P: FnMut<{unknown}> {
  type Item = {unknown};
}
impl Iterator for VarsOs {
  type Item = (OsString, OsString);
}
impl<A> Iterator for Range<A> where A: Step {
  type Item = A;
}
impl<R> Iterator for Bytes<R> where R: Read {
  type Item = Result<u8, Error>;
}
impl<K> Iterator for Drain<K> {
  type Item = K;
}
impl<T> Iterator for IntoIter<T> {
  type Item = T;
}
impl<K> Iterator for IntoIter<K> {
  type Item = K;
}
impl<A> Iterator for Iter<A> {
  type Item = &A;
}
impl<T> Iterator for IterMut<T> {
  type Item = &mut T;
}
impl<I, T, E> Iterator for ResultShunt<I, E> where I: Iterator, <I as Iterator>::Item = Result<T, E> {
  type Item = T;
}
impl<T, S> Iterator for Union<T, S> where T: Eq, T: Hash, S: BuildHasher {
  type Item = &T;
}
impl<T, P> Iterator for RSplit<T, P> where P: FnMut<{unknown}> {
  type Item = &[T];
}
impl<I, U> Iterator for Flatten<I> where I: Iterator, U: Iterator, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {
  type Item = {unknown};
}
impl<K, V> Iterator for IntoIter<K, V> {
  type Item = (K, V);
}
impl<T> Iterator for SymmetricDifference<T> where T: Ord {
  type Item = &T;
}
impl<T> Iterator for Iter<T> {
  type Item = &T;
}
impl<T> Iterator for Iter<T> {
  type Item = &T;
}
impl<A, B> Iterator for Chain<A, B> where A: Iterator, B: Iterator, <B as Iterator>::Item = {unknown} {
  type Item = {unknown};
}
impl<T> Iterator for IntoIter<T> {
  type Item = T;
}
impl<I> Iterator for Enumerate<I> where I: Iterator {
  type Item = ({unknown}, <I as Iterator>::Item);
}
impl<I> Iterator for StepBy<I> where I: Iterator {
  type Item = {unknown};
}
impl Iterator for Ancestors {
  type Item = &Path;
}
impl<I> Iterator for Fuse<I> where I: Iterator {
  type Item = <I as Iterator>::Item;
}
impl<K, V> Iterator for Values<K, V> {
  type Item = &V;
}
impl<I> Iterator for Rev<I> where I: DoubleEndedIterator {
  type Item = <I as Iterator>::Item;
}
impl<T> Iterator for IntoIter<T> {
  type Item = T;
}
impl<A> Iterator for RangeInclusive<A> where A: Step {
  type Item = A;
}
impl<K, V> Iterator for Values<K, V> {
  type Item = &V;
}
impl<I, P> Iterator for Filter<I, P> where I: Iterator, P: FnMut<{unknown}> {
  type Item = {unknown};
}
impl<T> Iterator for ChunksExact<T> {
  type Item = &[T];
}
impl<K, V> Iterator for Drain<K, V> {
  type Item = (K, V);
}
impl<T> Iterator for Chunks<T> {
  type Item = &[T];
}
impl Iterator for Bytes {
  type Item = u8;
}
impl<I> Iterator for Splice<I> where I: Iterator {
  type Item = {unknown};
}
impl<K, V> Iterator for Keys<K, V> {
  type Item = &K;
}
impl<T> Iterator for Iter<T> {
  type Item = &T;
}
impl Iterator for SplitWhitespace {
  type Item = &str;
}
impl<A> Iterator for RangeFrom<A> where A: Step {
  type Item = A;
}
impl<T> Iterator for Iter<T> {
  type Item = T;
}
impl<T, S> Iterator for Intersection<T, S> where T: Eq, T: Hash, S: BuildHasher {
  type Item = &T;
}
impl Iterator for EscapeUnicode {
  type Item = char;
}
impl<K, V> Iterator for RangeMut<K, V> {
  type Item = (&K, &mut V);
}
impl<A> Iterator for Item<A> {
  type Item = A;
}
impl<T> Iterator for Empty<T> {
  type Item = T;
}
impl Iterator for Wtf8CodePoints {
  type Item = CodePoint;
}
impl<A, F> Iterator for OnceWith<F> where F: FnOnce<{unknown}> {
  type Item = A;
}
impl<T, F> Iterator for DrainFilter<T, F> where F: FnMut<{unknown}> {
  type Item = T;
}
impl Iterator for LinesAny {
  type Item = &str;
}
impl<T> Iterator for RChunks<T> {
  type Item = &[T];
}
impl<I, P> Iterator for SkipWhile<I, P> where I: Iterator, P: FnMut<{unknown}> {
  type Item = {unknown};
}
impl Iterator for CaseMappingIter {
  type Item = char;
}
impl<T> Iterator for Difference<T> where T: Ord {
  type Item = &T;
}
impl<A> Iterator for IntoIter<A> {
  type Item = A;
}
impl Iterator for ToUppercase {
  type Item = char;
}
impl<K> Iterator for Iter<K> {
  type Item = &K;
}
impl<I, T> Iterator for OptionShunt<I> where I: Iterator, <I as Iterator>::Item = Option<T> {
  type Item = T;
}
impl<I, F> Iterator for Inspect<I, F> where I: Iterator, F: FnMut<{unknown}> {
  type Item = {unknown};
}
impl<I> Iterator for Cycle<I> where I: Clone, I: Iterator {
  type Item = <I as Iterator>::Item;
}
impl<I, U> Iterator for FlattenCompat<I, U> where I: Iterator, U: Iterator, {unknown}: IntoIterator, <{unknown} as IntoIterator>::IntoIter = U, <{unknown} as IntoIterator>::Item = {unknown} {
  type Item = {unknown};
}
impl<K, V> Iterator for Keys<K, V> {
  type Item = &K;
}
impl Iterator for Lines {
  type Item = &str;
}
impl<T, F> Iterator for FromFn<F> where F: FnMut<{unknown}> {
  type Item = T;
}
impl<K, V> Iterator for Range<K, V> {
  type Item = (&K, &V);
}
impl<B, I, F> Iterator for FilterMap<I, F> where I: Iterator, F: FnMut<{unknown}> {
  type Item = B;
}
impl Iterator for ReadDir {
  type Item = Result<DirEntry, Error>;
}
struct SymmetricDifference<T>;
struct Iter<T>;
struct Keys<K, V>;
struct ChunksExact<T>;
trait Sip {}
impl Sip for Sip13Rounds {}
impl Sip for Sip24Rounds {}
struct Chunks<T>;
struct Weak<T>;
struct Intersection<T, S>;
struct Box<T>;
struct Waker;
struct Difference<T>;
struct RChunks<T>;
struct String;
struct Keys<K, V>;
struct Iter<K>;
struct SocketAddrV4;
struct Iter<T>;
struct BuildHasherDefault<H>;
struct Values<K, V>;
struct BinaryHeap<T>;
struct BorrowRef;
struct Windows<T>;
struct Iter<K, V>;
struct Sender<T>;
struct Values<K, V>;
struct VaListImpl;
struct Union<T, S>;
struct SymmetricDifference<T, S>;
struct Union<T>;
struct Droppable;
trait FnMut<Args> {}
impl<A, F> FnMut<A> for &mut F where F: FnMut<A> {}
impl<A, F> FnMut<A> for &F where F: Fn<A> {}
struct Range<K, V>;
struct Iter<T>;
struct MaybeUninit<T>;
struct RChunksExact<T>;
struct Iter<T>;
struct SocketAddrV6;
struct Intersection<T>;
struct Iter<T>;
struct IntoIter<T>;
struct SyncSender<T>;
struct Weak<T>;
struct Iter<T>;
struct Difference<T, S>;
struct Option<T>;
struct Empty<T>;
struct Range<T>;
struct Iter<K, V>;
struct Hasher<S>;
trait Fn<Args> {}
impl<A, F> Fn<A> for &F where F: Fn<A> {}
struct Result<T, E>;