  
  test_impl_try_from_always_ok! { test_try_usizeusize, usize, usize }
  test_impl_try_from_always_ok! { test_try_isizeisize, isize, isize }
+diff --git a/src/libcore/time.rs b/src/libcore/time.rs
+index 81ae8ad..0e3dd39 100644
+--- a/src/libcore/time.rs
++++ b/src/libcore/time.rs
+@@ -30,7 +30,6 @@ const NANOS_PER_MILLI: u32 = 1_000_000;
+ const NANOS_PER_MICRO: u32 = 1_000;
+ const MILLIS_PER_SEC: u64 = 1_000;
+ const MICROS_PER_SEC: u64 = 1_000_000;
+-const MAX_NANOS_F64: f64 = ((u64::MAX as u128 + 1)*(NANOS_PER_SEC as u128)) as f64;
+ 
+ /// A `Duration` type to represent a span of time, typically used for system
+ /// timeouts.
+@@ -273,57 +272,6 @@ impl Duration {
+     #[inline]
+     pub const fn subsec_nanos(&self) -> u32 { self.nanos }
+ 
+-    /// Returns the total number of whole milliseconds contained by this `Duration`.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// # #![feature(duration_as_u128)]
+-    /// use std::time::Duration;
+-    ///
+-    /// let duration = Duration::new(5, 730023852);
+-    /// assert_eq!(duration.as_millis(), 5730);
+-    /// ```
+-    #[unstable(feature = "duration_as_u128", issue = "50202")]
+-    #[inline]
+-    pub fn as_millis(&self) -> u128 {
+-        self.secs as u128 * MILLIS_PER_SEC as u128 + (self.nanos / NANOS_PER_MILLI) as u128
+-    }
+-
+-    /// Returns the total number of whole microseconds contained by this `Duration`.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// # #![feature(duration_as_u128)]
+-    /// use std::time::Duration;
+-    ///
+-    /// let duration = Duration::new(5, 730023852);
+-    /// assert_eq!(duration.as_micros(), 5730023);
+-    /// ```
+-    #[unstable(feature = "duration_as_u128", issue = "50202")]
+-    #[inline]
+-    pub fn as_micros(&self) -> u128 {
+-        self.secs as u128 * MICROS_PER_SEC as u128 + (self.nanos / NANOS_PER_MICRO) as u128
+-    }
+-
+-    /// Returns the total number of nanoseconds contained by this `Duration`.
+-    ///
+-    /// # Examples
+-    ///
+-    /// ```
+-    /// # #![feature(duration_as_u128)]
+-    /// use std::time::Duration;
+-    ///
+-    /// let duration = Duration::new(5, 730023852);
+-    /// assert_eq!(duration.as_nanos(), 5730023852);
+-    /// ```
+-    #[unstable(feature = "duration_as_u128", issue = "50202")]
+-    #[inline]
+-    pub fn as_nanos(&self) -> u128 {
+-        self.secs as u128 * NANOS_PER_SEC as u128 + self.nanos as u128
+-    }
+-
+     /// Checked `Duration` addition. Computes `self + other`, returning [`None`]
+     /// if overflow occurred.
+     ///
+@@ -482,80 +430,6 @@ impl Duration {
+         (self.secs as f64) + (self.nanos as f64) / (NANOS_PER_SEC as f64)
+     }
+ 
+-    /// Creates a new `Duration` from the specified number of seconds.
+-    ///
+-    /// # Panics
+-    /// This constructor will panic if `secs` is not finite, negative or overflows `Duration`.
+-    ///
+-    /// # Examples
+-    /// ```
+-    /// #![feature(duration_float)]
+-    /// use std::time::Duration;
+-    ///
+-    /// let dur = Duration::from_float_secs(2.7);
+-    /// assert_eq!(dur, Duration::new(2, 700_000_000));
+-    /// ```
+-    #[unstable(feature = "duration_float", issue = "54361")]
+-    #[inline]
+-    pub fn from_float_secs(secs: f64) -> Duration {
+-        let nanos =  secs * (NANOS_PER_SEC as f64);
+-        if !nanos.is_finite() {
+-            panic!("got non-finite value when converting float to duration");
+-        }
+-        if nanos >= MAX_NANOS_F64 {
+-            panic!("overflow when converting float to duration");
+-        }
+-        if nanos < 0.0 {
+-            panic!("underflow when converting float to duration");
+-        }
+-        let nanos =  nanos as u128;
+-        Duration {
+-            secs: (nanos / (NANOS_PER_SEC as u128)) as u64,
+-            nanos: (nanos % (NANOS_PER_SEC as u128)) as u32,
+-        }
+-    }
+-
+-    /// Multiply `Duration` by `f64`.
+-    ///
+-    /// # Panics
+-    /// This method will panic if result is not finite, negative or overflows `Duration`.
+-    ///
+-    /// # Examples
+-    /// ```
+-    /// #![feature(duration_float)]
+-    /// use std::time::Duration;
+-    ///
+-    /// let dur = Duration::new(2, 700_000_000);
+-    /// assert_eq!(dur.mul_f64(3.14), Duration::new(8, 478_000_000));
+-    /// assert_eq!(dur.mul_f64(3.14e5), Duration::new(847_800, 0));
+-    /// ```
+-    #[unstable(feature = "duration_float", issue = "54361")]
+-    #[inline]
+-    pub fn mul_f64(self, rhs: f64) -> Duration {
+-        Duration::from_float_secs(rhs * self.as_float_secs())
+-    }
+-
+-    /// Divide `Duration` by `f64`.
+-    ///
+-    /// # Panics
+-    /// This method will panic if result is not finite, negative or overflows `Duration`.
+-    ///
+-    /// # Examples
+-    /// ```
+-    /// #![feature(duration_float)]
+-    /// use std::time::Duration;
+-    ///
+-    /// let dur = Duration::new(2, 700_000_000);
+-    /// assert_eq!(dur.div_f64(3.14), Duration::new(0, 859_872_611));
+-    /// // note that truncation is used, not rounding
+-    /// assert_eq!(dur.div_f64(3.14e5), Duration::new(0, 8_598));
+-    /// ```
+-    #[unstable(feature = "duration_float", issue = "54361")]
+-    #[inline]
+-    pub fn div_f64(self, rhs: f64) -> Duration {
+-        Duration::from_float_secs(self.as_float_secs() / rhs)
+-    }
+-
+     /// Divide `Duration` by `Duration` and return `f64`.
+     ///
+     /// # Examples
 -- 
 2.17.1 (Apple Git-112)
 

     /// Writes a single `isize` into this hasher.
     #[inline]
     #[stable(feature = "hasher_write", since = "1.3.0")]
@@ -380,9 +368,6 @@ impl<'a, H: Hasher + ?Sized> Hasher for &'a mut H {
     fn write_u64(&mut self, i: u64) {
         (**self).write_u64(i)
     }

 }
 
 #[cfg(target_pointer_width = "64")]
@@ -4633,24 +4604,20 @@ mod ptr_try_from_impls {
     use convert::TryFrom;
 
     try_from_upper_bounded!(usize, u8, u16, u32);
