--- a/Cargo.toml
+++ b/Cargo.toml
@@ -54,7 +54,7 @@
 optional = true
 
 [dependencies.static_assertions]
-version = "0.3.3"
+version = "1.1.0"
 [dev-dependencies.approx]
 version = "0.3.0"
 
--- a/src/atof/algorithm/small_powers.rs
+++ b/src/atof/algorithm/small_powers.rs
@@ -13,46 +13,46 @@
 
 cfg_if! {
 if #[cfg(has_const_index)] {
-const_assert!(small_powers_radix5; POW5[1] / POW5[0] == 5);
-const_assert!(small_powers_radix10; POW10[1] / POW10[0] == 10);
+const_assert!(POW5[1] / POW5[0] == 5);
+const_assert!(POW10[1] / POW10[0] == 10);
 }}  //cfg_if
 
 cfg_if! {
 if #[cfg(all(has_const_index, feature = "radix"))] {
 // Ensure our small powers are valid.
-const_assert!(small_powers_radix2; POW2[1] / POW2[0] == 2);
-const_assert!(small_powers_radix3; POW3[1] / POW3[0] == 3);
-const_assert!(small_powers_radix4; POW4[1] / POW4[0] == 4);
-const_assert!(small_powers_radix6; POW6[1] / POW6[0] == 6);
-const_assert!(small_powers_radix7; POW7[1] / POW7[0] == 7);
-const_assert!(small_powers_radix8; POW8[1] / POW8[0] == 8);
-const_assert!(small_powers_radix9; POW9[1] / POW9[0] == 9);
-const_assert!(small_powers_radix11; POW11[1] / POW11[0] == 11);
-const_assert!(small_powers_radix12; POW12[1] / POW12[0] == 12);
-const_assert!(small_powers_radix13; POW13[1] / POW13[0] == 13);
-const_assert!(small_powers_radix14; POW14[1] / POW14[0] == 14);
-const_assert!(small_powers_radix15; POW15[1] / POW15[0] == 15);
-const_assert!(small_powers_radix16; POW16[1] / POW16[0] == 16);
-const_assert!(small_powers_radix17; POW17[1] / POW17[0] == 17);
-const_assert!(small_powers_radix18; POW18[1] / POW18[0] == 18);
-const_assert!(small_powers_radix19; POW19[1] / POW19[0] == 19);
-const_assert!(small_powers_radix20; POW20[1] / POW20[0] == 20);
-const_assert!(small_powers_radix21; POW21[1] / POW21[0] == 21);
-const_assert!(small_powers_radix22; POW22[1] / POW22[0] == 22);
-const_assert!(small_powers_radix23; POW23[1] / POW23[0] == 23);
-const_assert!(small_powers_radix24; POW24[1] / POW24[0] == 24);
-const_assert!(small_powers_radix25; POW25[1] / POW25[0] == 25);
-const_assert!(small_powers_radix26; POW26[1] / POW26[0] == 26);
-const_assert!(small_powers_radix27; POW27[1] / POW27[0] == 27);
-const_assert!(small_powers_radix28; POW28[1] / POW28[0] == 28);
-const_assert!(small_powers_radix29; POW29[1] / POW29[0] == 29);
-const_assert!(small_powers_radix30; POW30[1] / POW30[0] == 30);
-const_assert!(small_powers_radix31; POW31[1] / POW31[0] == 31);
-const_assert!(small_powers_radix32; POW32[1] / POW32[0] == 32);
-const_assert!(small_powers_radix33; POW33[1] / POW33[0] == 33);
-const_assert!(small_powers_radix34; POW34[1] / POW34[0] == 34);
-const_assert!(small_powers_radix35; POW35[1] / POW35[0] == 35);
-const_assert!(small_powers_radix36; POW36[1] / POW36[0] == 36);
+const_assert!(POW2[1] / POW2[0] == 2);
+const_assert!(POW3[1] / POW3[0] == 3);
+const_assert!(POW4[1] / POW4[0] == 4);
+const_assert!(POW6[1] / POW6[0] == 6);
+const_assert!(POW7[1] / POW7[0] == 7);
+const_assert!(POW8[1] / POW8[0] == 8);
+const_assert!(POW9[1] / POW9[0] == 9);
+const_assert!(POW11[1] / POW11[0] == 11);
+const_assert!(POW12[1] / POW12[0] == 12);
+const_assert!(POW13[1] / POW13[0] == 13);
+const_assert!(POW14[1] / POW14[0] == 14);
+const_assert!(POW15[1] / POW15[0] == 15);
+const_assert!(POW16[1] / POW16[0] == 16);
+const_assert!(POW17[1] / POW17[0] == 17);
+const_assert!(POW18[1] / POW18[0] == 18);
+const_assert!(POW19[1] / POW19[0] == 19);
+const_assert!(POW20[1] / POW20[0] == 20);
+const_assert!(POW21[1] / POW21[0] == 21);
+const_assert!(POW22[1] / POW22[0] == 22);
+const_assert!(POW23[1] / POW23[0] == 23);
+const_assert!(POW24[1] / POW24[0] == 24);
+const_assert!(POW25[1] / POW25[0] == 25);
+const_assert!(POW26[1] / POW26[0] == 26);
+const_assert!(POW27[1] / POW27[0] == 27);
+const_assert!(POW28[1] / POW28[0] == 28);
+const_assert!(POW29[1] / POW29[0] == 29);
+const_assert!(POW30[1] / POW30[0] == 30);
+const_assert!(POW31[1] / POW31[0] == 31);
+const_assert!(POW32[1] / POW32[0] == 32);
+const_assert!(POW33[1] / POW33[0] == 33);
+const_assert!(POW34[1] / POW34[0] == 34);
+const_assert!(POW35[1] / POW35[0] == 35);
+const_assert!(POW36[1] / POW36[0] == 36);
 
 }}  //cfg_if
 
--- a/src/util/table.rs
+++ b/src/util/table.rs
@@ -752,97 +752,97 @@
 
 // Compile-time guarantees for our tables.
 #[cfg(has_const_index)]
-const_assert!(f32_pow10; F32_POW10[1] / F32_POW10[0] == 10.0);
+const_assert!(F32_POW10[1] / F32_POW10[0] == 10.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow2; F32_POW2[1] / F32_POW2[0] == 2.0);
+const_assert!(F32_POW2[1] / F32_POW2[0] == 2.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow3; F32_POW3[1] / F32_POW3[0] == 3.0);
+const_assert!(F32_POW3[1] / F32_POW3[0] == 3.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow5; F32_POW5[1] / F32_POW5[0] == 5.0);
+const_assert!(F32_POW5[1] / F32_POW5[0] == 5.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow6; F32_POW6[1] / F32_POW6[0] == 6.0);
+const_assert!(F32_POW6[1] / F32_POW6[0] == 6.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow7; F32_POW7[1] / F32_POW7[0] == 7.0);
+const_assert!(F32_POW7[1] / F32_POW7[0] == 7.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow9; F32_POW9[1] / F32_POW9[0] == 9.0);
+const_assert!(F32_POW9[1] / F32_POW9[0] == 9.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow11; F32_POW11[1] / F32_POW11[0] == 11.0);
+const_assert!(F32_POW11[1] / F32_POW11[0] == 11.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow12; F32_POW12[1] / F32_POW12[0] == 12.0);
+const_assert!(F32_POW12[1] / F32_POW12[0] == 12.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow13; F32_POW13[1] / F32_POW13[0] == 13.0);
+const_assert!(F32_POW13[1] / F32_POW13[0] == 13.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow14; F32_POW14[1] / F32_POW14[0] == 14.0);
+const_assert!(F32_POW14[1] / F32_POW14[0] == 14.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow15; F32_POW15[1] / F32_POW15[0] == 15.0);
+const_assert!(F32_POW15[1] / F32_POW15[0] == 15.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow17; F32_POW17[1] / F32_POW17[0] == 17.0);
+const_assert!(F32_POW17[1] / F32_POW17[0] == 17.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow18; F32_POW18[1] / F32_POW18[0] == 18.0);
+const_assert!(F32_POW18[1] / F32_POW18[0] == 18.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow19; F32_POW19[1] / F32_POW19[0] == 19.0);
+const_assert!(F32_POW19[1] / F32_POW19[0] == 19.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow20; F32_POW20[1] / F32_POW20[0] == 20.0);
+const_assert!(F32_POW20[1] / F32_POW20[0] == 20.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow21; F32_POW21[1] / F32_POW21[0] == 21.0);
+const_assert!(F32_POW21[1] / F32_POW21[0] == 21.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow22; F32_POW22[1] / F32_POW22[0] == 22.0);
+const_assert!(F32_POW22[1] / F32_POW22[0] == 22.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow23; F32_POW23[1] / F32_POW23[0] == 23.0);
+const_assert!(F32_POW23[1] / F32_POW23[0] == 23.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow24; F32_POW24[1] / F32_POW24[0] == 24.0);
+const_assert!(F32_POW24[1] / F32_POW24[0] == 24.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow25; F32_POW25[1] / F32_POW25[0] == 25.0);
+const_assert!(F32_POW25[1] / F32_POW25[0] == 25.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow26; F32_POW26[1] / F32_POW26[0] == 26.0);
+const_assert!(F32_POW26[1] / F32_POW26[0] == 26.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow27; F32_POW27[1] / F32_POW27[0] == 27.0);
+const_assert!(F32_POW27[1] / F32_POW27[0] == 27.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow28; F32_POW28[1] / F32_POW28[0] == 28.0);
+const_assert!(F32_POW28[1] / F32_POW28[0] == 28.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow29; F32_POW29[1] / F32_POW29[0] == 29.0);
+const_assert!(F32_POW29[1] / F32_POW29[0] == 29.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow30; F32_POW30[1] / F32_POW30[0] == 30.0);
+const_assert!(F32_POW30[1] / F32_POW30[0] == 30.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow31; F32_POW31[1] / F32_POW31[0] == 31.0);
+const_assert!(F32_POW31[1] / F32_POW31[0] == 31.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow33; F32_POW33[1] / F32_POW33[0] == 33.0);
+const_assert!(F32_POW33[1] / F32_POW33[0] == 33.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow34; F32_POW34[1] / F32_POW34[0] == 34.0);
+const_assert!(F32_POW34[1] / F32_POW34[0] == 34.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow35; F32_POW35[1] / F32_POW35[0] == 35.0);
+const_assert!(F32_POW35[1] / F32_POW35[0] == 35.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f32_pow36; F32_POW36[1] / F32_POW36[0] == 36.0);
+const_assert!(F32_POW36[1] / F32_POW36[0] == 36.0);
 
 impl TablePower for f32 {
     const POW2_EXPONENT_BIAS: i32 = 149;
@@ -3106,97 +3106,97 @@
 
 // Compile-time guarantees for our tables.
 #[cfg(has_const_index)]
-const_assert!(f64_pow10; F64_POW10[1] / F64_POW10[0] == 10.0);
+const_assert!(F64_POW10[1] / F64_POW10[0] == 10.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow2; F64_POW2[1] / F64_POW2[0] == 2.0);
+const_assert!(F64_POW2[1] / F64_POW2[0] == 2.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow3; F64_POW3[1] / F64_POW3[0] == 3.0);
+const_assert!(F64_POW3[1] / F64_POW3[0] == 3.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow5; F64_POW5[1] / F64_POW5[0] == 5.0);
+const_assert!(F64_POW5[1] / F64_POW5[0] == 5.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow6; F64_POW6[1] / F64_POW6[0] == 6.0);
+const_assert!(F64_POW6[1] / F64_POW6[0] == 6.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow7; F64_POW7[1] / F64_POW7[0] == 7.0);
+const_assert!(F64_POW7[1] / F64_POW7[0] == 7.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow9; F64_POW9[1] / F64_POW9[0] == 9.0);
+const_assert!(F64_POW9[1] / F64_POW9[0] == 9.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow11; F64_POW11[1] / F64_POW11[0] == 11.0);
+const_assert!(F64_POW11[1] / F64_POW11[0] == 11.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow12; F64_POW12[1] / F64_POW12[0] == 12.0);
+const_assert!(F64_POW12[1] / F64_POW12[0] == 12.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow13; F64_POW13[1] / F64_POW13[0] == 13.0);
+const_assert!(F64_POW13[1] / F64_POW13[0] == 13.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow14; F64_POW14[1] / F64_POW14[0] == 14.0);
+const_assert!(F64_POW14[1] / F64_POW14[0] == 14.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow15; F64_POW15[1] / F64_POW15[0] == 15.0);
+const_assert!(F64_POW15[1] / F64_POW15[0] == 15.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow17; F64_POW17[1] / F64_POW17[0] == 17.0);
+const_assert!(F64_POW17[1] / F64_POW17[0] == 17.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow18; F64_POW18[1] / F64_POW18[0] == 18.0);
+const_assert!(F64_POW18[1] / F64_POW18[0] == 18.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow19; F64_POW19[1] / F64_POW19[0] == 19.0);
+const_assert!(F64_POW19[1] / F64_POW19[0] == 19.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow20; F64_POW20[1] / F64_POW20[0] == 20.0);
+const_assert!(F64_POW20[1] / F64_POW20[0] == 20.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow21; F64_POW21[1] / F64_POW21[0] == 21.0);
+const_assert!(F64_POW21[1] / F64_POW21[0] == 21.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow22; F64_POW22[1] / F64_POW22[0] == 22.0);
+const_assert!(F64_POW22[1] / F64_POW22[0] == 22.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow23; F64_POW23[1] / F64_POW23[0] == 23.0);
+const_assert!(F64_POW23[1] / F64_POW23[0] == 23.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow24; F64_POW24[1] / F64_POW24[0] == 24.0);
+const_assert!(F64_POW24[1] / F64_POW24[0] == 24.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow25; F64_POW25[1] / F64_POW25[0] == 25.0);
+const_assert!(F64_POW25[1] / F64_POW25[0] == 25.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow26; F64_POW26[1] / F64_POW26[0] == 26.0);
+const_assert!(F64_POW26[1] / F64_POW26[0] == 26.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow27; F64_POW27[1] / F64_POW27[0] == 27.0);
+const_assert!(F64_POW27[1] / F64_POW27[0] == 27.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow28; F64_POW28[1] / F64_POW28[0] == 28.0);
+const_assert!(F64_POW28[1] / F64_POW28[0] == 28.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow29; F64_POW29[1] / F64_POW29[0] == 29.0);
+const_assert!(F64_POW29[1] / F64_POW29[0] == 29.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow30; F64_POW30[1] / F64_POW30[0] == 30.0);
+const_assert!(F64_POW30[1] / F64_POW30[0] == 30.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow31; F64_POW31[1] / F64_POW31[0] == 31.0);
+const_assert!(F64_POW31[1] / F64_POW31[0] == 31.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow33; F64_POW33[1] / F64_POW33[0] == 33.0);
+const_assert!(F64_POW33[1] / F64_POW33[0] == 33.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow34; F64_POW34[1] / F64_POW34[0] == 34.0);
+const_assert!(F64_POW34[1] / F64_POW34[0] == 34.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow35; F64_POW35[1] / F64_POW35[0] == 35.0);
+const_assert!(F64_POW35[1] / F64_POW35[0] == 35.0);
 
 #[cfg(all(has_const_index, feature = "radix"))]
-const_assert!(f64_pow36; F64_POW36[1] / F64_POW36[0] == 36.0);
+const_assert!(F64_POW36[1] / F64_POW36[0] == 36.0);
 
 impl TablePower for f64 {
     const POW2_EXPONENT_BIAS: i32 = 1074;
