use std::collections::hash_map::{self, HashMap};

 use std::hash::Hash;

 use std::hash::{Hasher, BuildHasherDefault};

 use std::mem;

 use std::ops::{Index, IndexMut};

 use std::ptr;

         // This expects to receive one and exactly one 64-bit value

         debug_assert!(bytes.len() == 8);

         unsafe {

         }

     }

 

 

 // #[derive(Clone)] would want A to implement Clone, but in reality it’s only Box<A> that can.

 impl<A: ?Sized + UncheckedAnyExt> Clone for RawMap<A> where Box<A>: Clone {

     fn clone(&self) -> RawMap<A> {

         RawMap {

             inner: self.inner.clone(),

 }

 

 impl<A: ?Sized + UncheckedAnyExt> Default for RawMap<A> {

     fn default() -> RawMap<A> {

         RawMap::new()

     }

     with_capacity(capacity) => HashMap::with_capacity_and_hasher(capacity, Default::default());

 }

 

 #[derive(Clone)]

 pub struct Iter<'a, A: ?Sized + UncheckedAnyExt> {

     inner: hash_map::Iter<'a, TypeId, Box<A>>,

     #[inline] fn len(&self) -> usize { self.inner.len() }

 }

 

 pub struct IterMut<'a, A: ?Sized + UncheckedAnyExt> {

     inner: hash_map::IterMut<'a, TypeId, Box<A>>,

 }

     #[inline] fn len(&self) -> usize { self.inner.len() }

 }

 

 pub struct IntoIter<A: ?Sized + UncheckedAnyExt> {

     inner: hash_map::IntoIter<TypeId, Box<A>>,

 }

     #[inline] fn len(&self) -> usize { self.inner.len() }

 }

 

 pub struct Drain<'a, A: ?Sized + UncheckedAnyExt> {

     inner: hash_map::Drain<'a, TypeId, Box<A>>,

 }

     }

 

     /// Gets the entry for the given type in the collection for in-place manipulation.

     pub fn entry(&mut self, key: TypeId) -> Entry<A> {

         match self.inner.entry(key) {

             hash_map::Entry::Occupied(e) => Entry::Occupied(OccupiedEntry {

     ///

     /// The key may be any borrowed form of the map's key type, but `Hash` and `Eq` on the borrowed

     /// form *must* match those for the key type.

     pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&A>

     where TypeId: Borrow<Q>, Q: Hash + Eq {

         self.inner.get(k).map(|x| &**x)

     ///

     /// The key may be any borrowed form of the map's key type, but `Hash` and `Eq` on the borrowed

     /// form *must* match those for the key type.

     pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool

     where TypeId: Borrow<Q>, Q: Hash + Eq {

         self.inner.contains_key(k)

     ///

     /// The key may be any borrowed form of the map's key type, but `Hash` and `Eq` on the borrowed

     /// form *must* match those for the key type.

     pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut A>

     where TypeId: Borrow<Q>, Q: Hash + Eq {

         self.inner.get_mut(k).map(|x| &mut **x)

     ///

     /// It is the caller’s responsibility to ensure that the key corresponds with the type ID of

     /// the value. If they do not, memory safety may be violated.

     pub unsafe fn insert(&mut self, key: TypeId, value: Box<A>) -> Option<Box<A>> {

         self.inner.insert(key, value)

     }

     ///

     /// The key may be any borrowed form of the map's key type, but `Hash` and `Eq` on the borrowed

     /// form *must* match those for the key type.

     pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<Box<A>>

     where TypeId: Borrow<Q>, Q: Hash + Eq {

         self.inner.remove(k)

 impl<A: ?Sized + UncheckedAnyExt, Q> Index<Q> for RawMap<A> where TypeId: Borrow<Q>, Q: Eq + Hash {

     type Output = A;

 

     fn index(&self, index: Q) -> &A {

         self.get(&index).expect("no entry found for key")

     }

 }

 

 impl<A: ?Sized + UncheckedAnyExt, Q> IndexMut<Q> for RawMap<A> where TypeId: Borrow<Q>, Q: Eq + Hash {

     fn index_mut(&mut self, index: Q) -> &mut A {

         self.get_mut(&index).expect("no entry found for key")

     }

     type Item = Box<A>;

     type IntoIter = IntoIter<A>;

 

     fn into_iter(self) -> IntoIter<A> {

         IntoIter {

             inner: self.inner.into_iter(),

     ///

     /// It is the caller’s responsibility to ensure that the key of the entry corresponds with

     /// the type ID of `value`. If they do not, memory safety may be violated.

     pub unsafe fn or_insert(self, default: Box<A>) -> &'a mut A {

         match self {

             Entry::Occupied(inner) => inner.into_mut(),

     ///

     /// It is the caller’s responsibility to ensure that the key of the entry corresponds with

     /// the type ID of `value`. If they do not, memory safety may be violated.

     pub unsafe fn or_insert_with<F: FnOnce() -> Box<A>>(self, default: F) -> &'a mut A {

         match self {

             Entry::Occupied(inner) => inner.into_mut(),

 

 impl<'a, A: ?Sized + UncheckedAnyExt> OccupiedEntry<'a, A> {

     /// Gets a reference to the value in the entry.

     pub fn get(&self) -> &A {

         &**self.inner.get() 

     }

 

     /// Gets a mutable reference to the value in the entry.

     pub fn get_mut(&mut self) -> &mut A {

         &mut **self.inner.get_mut()

     }

 

     /// Converts the OccupiedEntry into a mutable reference to the value in the entry

     /// with a lifetime bound to the collection itself.

     pub fn into_mut(self) -> &'a mut A {

         &mut **self.inner.into_mut()

     }

     ///

     /// It is the caller’s responsibility to ensure that the key of the entry corresponds with

     /// the type ID of `value`. If they do not, memory safety may be violated.

     pub unsafe fn insert(&mut self, value: Box<A>) -> Box<A> {

         self.inner.insert(value)

     }

 

     /// Takes the value out of the entry, and returns it.

     pub fn remove(self) -> Box<A> {

         self.inner.remove()

     }

     ///

     /// It is the caller’s responsibility to ensure that the key of the entry corresponds with

     /// the type ID of `value`. If they do not, memory safety may be violated.

     pub unsafe fn insert(self, value: Box<A>) -> &'a mut A {

         &mut **self.inner.insert(value)

     }