diff --git a/src/dec2flt/algorithm.rs b/src/dec2flt/algorithm.rs
index 2b0b4cb..76d8105 100644
--- a/src/dec2flt/algorithm.rs
+++ b/src/dec2flt/algorithm.rs
@@ -110,7 +110,7 @@ mod fpu_precision {
 ///
 /// This is extracted into a separate function so that it can be attempted before constructing
 /// a bignum.
-pub fn fast_path<T: RawFloat>(integral: &[u8], fractional: &[u8], e: i64) -> Option<T> {
+pub fn fast_path<T: RawFloat>(integral: &[u8], fractional: &[u8], mut e: i64) -> Option<T> {
     let num_digits = integral.len() + fractional.len();
     // log_10(f64::MAX_SIG) ~ 15.95. We compare the exact value to MAX_SIG near the end,
     // this is just a quick, cheap rejection (and also frees the rest of the code from
@@ -118,14 +118,29 @@ pub fn fast_path<T: RawFloat>(integral: &[u8], fractional: &[u8], e: i64) -> Opt
     if num_digits > 16 {
         return None;
     }
-    if e.abs() >= T::CEIL_LOG5_OF_MAX_SIG as i64 {
+    let max_exp = T::FLOOR_LOG5_OF_MAX_SIG as i64;
+    let min_exp = -max_exp;
+    let shift_exp = T::FLOOR_LOG10_OF_MAX_SIG as i64;
+    let disguised_exp = max_exp + shift_exp;
+    if e < min_exp || e > disguised_exp {
         return None;
     }
-    let f = num::from_str_unchecked(integral.iter().chain(fractional.iter()));
+    let mut f = num::from_str_unchecked(integral.iter().chain(fractional.iter()));
     if f > T::MAX_SIG {
         return None;
     }
 
+    // Handle a disguised fast path case here.
+    if e > max_exp {
+        let shift = e - max_exp;
+        let value = f.checked_mul(T::short_int_pow10(shift as usize))?;
+        if value > T::MAX_SIG {
+            return None;
+        }
+        f = value;
+        e = max_exp;
+    }
+
     // The fast path crucially depends on arithmetic being rounded to the correct number of bits
     // without any intermediate rounding. On x86 (without SSE or SSE2) this requires the precision
     // of the x87 FPU stack to be changed so that it directly rounds to 64/32 bit.
diff --git a/src/dec2flt/rawfp.rs b/src/dec2flt/rawfp.rs
index a3acf3d..15a5839 100644
--- a/src/dec2flt/rawfp.rs
+++ b/src/dec2flt/rawfp.rs
@@ -73,13 +73,21 @@ pub trait RawFloat:
     /// represented, the other code in this module makes sure to never let that happen.
     fn from_int(x: u64) -> Self;
 
+    fn short_int_pow10(e: usize) -> u64 {
+        table::SHORT_POWERS[e]
+    }
+
     /// Gets the value 10<sup>e</sup> from a pre-computed table.
-    /// Panics for `e >= CEIL_LOG5_OF_MAX_SIG`.
+    /// Panics for `e >= FLOOR_LOG5_OF_MAX_SIG`.
     fn short_fast_pow10(e: usize) -> Self;
 
     /// What the name says. It's easier to hard code than juggling intrinsics and
     /// hoping LLVM constant folds it.
-    const CEIL_LOG5_OF_MAX_SIG: i16;
+    const FLOOR_LOG5_OF_MAX_SIG: i16;
+
+    /// What the name says. It's easier to hard code than juggling intrinsics and
+    /// hoping LLVM constant folds it.
+    const FLOOR_LOG10_OF_MAX_SIG: i16;
 
     // A conservative bound on the decimal digits of inputs that can't produce overflow or zero or
     /// subnormals. Probably the decimal exponent of the maximum normal value, hence the name.
@@ -147,7 +155,8 @@ impl RawFloat for f32 {
 
     const SIG_BITS: u8 = 24;
     const EXP_BITS: u8 = 8;
-    const CEIL_LOG5_OF_MAX_SIG: i16 = 11;
+    const FLOOR_LOG5_OF_MAX_SIG: i16 = 10;
+    const FLOOR_LOG10_OF_MAX_SIG: i16 = 7;
     const MAX_NORMAL_DIGITS: usize = 35;
     const INF_CUTOFF: i64 = 40;
     const ZERO_CUTOFF: i64 = -48;
@@ -196,7 +205,8 @@ impl RawFloat for f64 {
 
     const SIG_BITS: u8 = 53;
     const EXP_BITS: u8 = 11;
-    const CEIL_LOG5_OF_MAX_SIG: i16 = 23;
+    const FLOOR_LOG5_OF_MAX_SIG: i16 = 22;
+    const FLOOR_LOG10_OF_MAX_SIG: i16 = 15;
     const MAX_NORMAL_DIGITS: usize = 305;
     const INF_CUTOFF: i64 = 310;
     const ZERO_CUTOFF: i64 = -326;
diff --git a/src/dec2flt/table.rs b/src/dec2flt/table.rs
index 97b497e..bd9e53d 100644
--- a/src/dec2flt/table.rs
+++ b/src/dec2flt/table.rs
@@ -1234,6 +1234,30 @@ pub static POWERS: ([u64; 611], [i16; 611]) = (
     ],
 );
 
+#[rustfmt::skip]
+pub const SHORT_POWERS: [u64; 20] = [
+    1,
+    10,
+    100,
+    1000,
+    10000,
+    100000,
+    1000000,
+    10000000,
+    100000000,
+    1000000000,
+    10000000000,
+    100000000000,
+    1000000000000,
+    10000000000000,
+    100000000000000,
+    1000000000000000,
+    10000000000000000,
+    100000000000000000,
+    1000000000000000000,
+    10000000000000000000,
+];
+
 #[rustfmt::skip]
 pub const F32_SHORT_POWERS: [f32; 11] = [
     1e0,