html-to-markdown 2.24.1 → 2.24.3

data/rust-vendor/zerocopy-derive/tests/ui-stable/enum.stderr

@@ -439,7 +439,7 @@ help: the trait `PaddingFree<IntoBytes1, 1>` is not implemented for `()`
       but trait `PaddingFree<IntoBytes1, 0>` is implemented for it
    --> $WORKSPACE/src/util/macro_util.rs
     |
- 65 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
+ 62 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -457,7 +457,7 @@ help: the trait `PaddingFree<IntoBytes2, 3>` is not implemented for `()`
       but trait `PaddingFree<IntoBytes2, 0>` is implemented for it
    --> $WORKSPACE/src/util/macro_util.rs
     |
- 65 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
+ 62 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -475,7 +475,7 @@ help: the trait `PaddingFree<IntoBytes3, 2>` is not implemented for `()`
       but trait `PaddingFree<IntoBytes3, 0>` is implemented for it
    --> $WORKSPACE/src/util/macro_util.rs
     |
- 65 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
+ 62 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)

data/rust-vendor/zerocopy-derive/tests/ui-stable/struct.stderr

@@ -293,7 +293,7 @@ help: the trait `PaddingFree<IntoBytes2, 1>` is not implemented for `()`
       but trait `PaddingFree<IntoBytes2, 0>` is implemented for it
    --> $WORKSPACE/src/util/macro_util.rs
     |
- 65 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
+ 62 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -311,7 +311,7 @@ help: the trait `PaddingFree<IntoBytes3, 1>` is not implemented for `()`
       but trait `PaddingFree<IntoBytes3, 0>` is implemented for it
    --> $WORKSPACE/src/util/macro_util.rs
     |
- 65 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
+ 62 | impl<T: ?Sized> PaddingFree<T, 0> for () {}
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -365,7 +365,7 @@ help: the trait `DynamicPaddingFree<IntoBytes5, true>` is not implemented for `(
       but trait `DynamicPaddingFree<IntoBytes5, false>` is implemented for it
    --> $WORKSPACE/src/util/macro_util.rs
     |
- 83 | impl<T: ?Sized> DynamicPaddingFree<T, false> for () {}
+ 80 | impl<T: ?Sized> DynamicPaddingFree<T, false> for () {}
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -383,7 +383,7 @@ help: the trait `DynamicPaddingFree<IntoBytes6, true>` is not implemented for `(
       but trait `DynamicPaddingFree<IntoBytes6, false>` is implemented for it
    --> $WORKSPACE/src/util/macro_util.rs
     |
- 83 | impl<T: ?Sized> DynamicPaddingFree<T, false> for () {}
+ 80 | impl<T: ?Sized> DynamicPaddingFree<T, false> for () {}
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -401,7 +401,7 @@ help: the trait `DynamicPaddingFree<IntoBytes7, true>` is not implemented for `(
       but trait `DynamicPaddingFree<IntoBytes7, false>` is implemented for it
    --> $WORKSPACE/src/util/macro_util.rs
     |
- 83 | impl<T: ?Sized> DynamicPaddingFree<T, false> for () {}
+ 80 | impl<T: ?Sized> DynamicPaddingFree<T, false> for () {}
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     = help: see issue #48214
     = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)

data/rust-vendor/zmij/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{".cargo_vcs_info.json":"896db6a00a278b78790f0caed75b0f00c6e176f7da0925c043fc36436df3832d",".github/workflows/ci.yml":"c6a8fe8d53e0556a4ebaefae94a0b2ffa74288e1652093667b135ed37f4374f2","Cargo.lock":"e43e0cc64ab8679454ccfe278646a24d81ad8268aa98d8d673f63a65ec18c16d","Cargo.toml":"eef7de4eba70aa061a4057cc8f069a7bc1d44919a4d166a662af1496eaa26920","Cargo.toml.orig":"b483331d2bcac27f8122d9e5ac2743bce859e765b7c4373c6dab2eb6ce813f39","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"65315bd4766121389659b6bdc6cdad1ba5cb837cf948d8630aa8cec81a827afa","benches/bench.rs":"28d23a29046c4d50c73a19fd81ad80cc97e474af6d8c30f81dcc8c9621065cca","build.rs":"13201b550236a9ff2186b5303c77341d3b0874989fdaf39613a7452e4ce57817","src/hint.rs":"7e03e3c031b7c20127517b794a4b641b3efb6ccd4c7b1aae1b7b6f28b9968052","src/lib.rs":"8aa33c9a00f49219eeaf9b0f3ef3fedcbbf0301bc2fcf7885b7885e65a60f602","src/stdarch_x86.rs":"b19b4c54f0c08c92f96d18c152f796d85cc17f9e6195f3e7d5612f05f28836fb","src/tests.rs":"04ba0d4a2b0e46e0c4f294af3bc1a1c938e72b7f9d0435b2eac0848ce5d4866a","src/traits.rs":"d289ade8d66f03096349f1cf2d4e68fad792e7b089bc956410cf700d9aad67e1","tests/exhaustive.rs":"3d5c1036dcb391bfd038fcb9feb03380b467a184ed9e0463d52f35b521684029","tests/ryu_comparison.rs":"5874eaff05486484029b333a8e7104db62b2706c8e64aecd69d8ccffad0880c3","tests/test.rs":"0f5efa4354a932d767ed561ddee411a10dd71faafa202372f3c00d81b88d1381"},"package":"02aae0f83f69aafc94776e879363e9771d7ecbffe2c7fbb6c14c5e00dfe88439"}
+{"files":{".cargo_vcs_info.json":"fc4cfe0823e2b7f29e3cbf71460386760fe0e52e23fd2d654b588bd60b29a99d",".github/workflows/ci.yml":"c6a8fe8d53e0556a4ebaefae94a0b2ffa74288e1652093667b135ed37f4374f2","Cargo.lock":"d4964a22db25c234c84332212016fdab413d4c8cabde24bcd5d57f8f4b6da042","Cargo.toml":"206bff1b72ce6a6d5123d53a6a4930ec103a634efd03deec287f437fc0c54e44","Cargo.toml.orig":"a65a097cbb8779590a2243773290f7dddb2bcaa904255485428dd4c1be39272f","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"cb4094e229373958e8de8b88048f7f09ce41b403b14543469354ba4049075eda","benches/bench.rs":"28d23a29046c4d50c73a19fd81ad80cc97e474af6d8c30f81dcc8c9621065cca","build.rs":"13201b550236a9ff2186b5303c77341d3b0874989fdaf39613a7452e4ce57817","src/hint.rs":"7e03e3c031b7c20127517b794a4b641b3efb6ccd4c7b1aae1b7b6f28b9968052","src/lib.rs":"15a8f3dda4a51320e1da93a052f015b2a9cc720306d3967dce854feab44f96de","src/stdarch_x86.rs":"b19b4c54f0c08c92f96d18c152f796d85cc17f9e6195f3e7d5612f05f28836fb","src/tests.rs":"04ba0d4a2b0e46e0c4f294af3bc1a1c938e72b7f9d0435b2eac0848ce5d4866a","src/traits.rs":"d289ade8d66f03096349f1cf2d4e68fad792e7b089bc956410cf700d9aad67e1","tests/exhaustive.rs":"3d5c1036dcb391bfd038fcb9feb03380b467a184ed9e0463d52f35b521684029","tests/ryu_comparison.rs":"5874eaff05486484029b333a8e7104db62b2706c8e64aecd69d8ccffad0880c3","tests/test.rs":"0f5efa4354a932d767ed561ddee411a10dd71faafa202372f3c00d81b88d1381"},"package":"1966f8ac2c1f76987d69a74d0e0f929241c10e78136434e3be70ff7f58f64214"}

data/rust-vendor/zmij/.cargo_vcs_info.json

@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "60c35b195b3b19dc6f49f6004dad70e6457fb30c"
+    "sha1": "3a9446327c05de8446d7423854bbb03d0b243968"
   },
   "path_in_vcs": ""
 }

data/rust-vendor/zmij/Cargo.lock

@@ -46,9 +46,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.54"
+version = "1.2.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6354c81bbfd62d9cfa9cb3c773c2b7b2a3a482d569de977fd0e961f6e7c00583"
+checksum = "47b26a0954ae34af09b50f0de26458fa95369a0d478d8236d3f93082b219bd29"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -89,18 +89,18 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.54"
+version = "4.5.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
+checksum = "a75ca66430e33a14957acc24c5077b503e7d374151b2b4b3a10c83b4ceb4be0e"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.5.54"
+version = "4.5.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
+checksum = "793207c7fa6300a0608d1080b858e5fdbe713cdc1c8db9fb17777d8a13e63df0"
 dependencies = [
  "anstyle",
  "clap_lex",
@@ -159,9 +159,9 @@ checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
 [[package]]
 name = "getrandom"
@@ -436,7 +436,7 @@ dependencies = [
  "memchr",
  "serde",
  "serde_core",
- "zmij 1.0.16",
+ "zmij 1.0.17",
 ]
 
 [[package]]
@@ -545,18 +545,18 @@ checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.33"
+version = "0.8.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
+checksum = "7456cf00f0685ad319c5b1693f291a650eaf345e941d082fc4e03df8a03996ac"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.33"
+version = "0.8.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
+checksum = "1328722bbf2115db7e19d69ebcc15e795719e2d66b60827c6a69a117365e37a0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -565,13 +565,13 @@ dependencies = [
 
 [[package]]
 name = "zmij"
-version = "1.0.16"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65"
+checksum = "02aae0f83f69aafc94776e879363e9771d7ecbffe2c7fbb6c14c5e00dfe88439"
 
 [[package]]
 name = "zmij"
-version = "1.0.17"
+version = "1.0.18"
 dependencies = [
  "criterion",
  "no-panic",

data/rust-vendor/zmij/Cargo.toml

@@ -13,7 +13,7 @@
 edition = "2021"
 rust-version = "1.68"
 name = "zmij"
-version = "1.0.17"
+version = "1.0.18"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 exclude = ["*.png"]

data/rust-vendor/zmij/Cargo.toml.orig

@@ -1,6 +1,6 @@
 [package]
 name = "zmij"
-version = "1.0.17"
+version = "1.0.18"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 categories = ["value-formatting", "no-std", "no-std::no-alloc"]
 description = "A double-to-string conversion algorithm based on Schubfach and yy"

data/rust-vendor/zmij/README.md

@@ -11,7 +11,7 @@ numbers to decimal strings.
 This Rust implementation is a line-by-line port of Victor Zverovich's
 implementation in C++, [https://github.com/vitaut/zmij][upstream].
 
-[upstream]: https://github.com/vitaut/zmij/tree/25bd96ee970eadf94f08fbd6ff39b712c4f55e7e
+[upstream]: https://github.com/vitaut/zmij/tree/fb4fafadd8ad318df51ee00140699062db8d5b3e
 
 ## Example
 

data/rust-vendor/zmij/src/lib.rs

@@ -41,7 +41,7 @@
 //! ![performance](https://raw.githubusercontent.com/dtolnay/zmij/master/dtoa-benchmark.png)
 
 #![no_std]
-#![doc(html_root_url = "https://docs.rs/zmij/1.0.17")]
+#![doc(html_root_url = "https://docs.rs/zmij/1.0.18")]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![allow(non_camel_case_types, non_snake_case)]
 #![allow(
@@ -305,6 +305,7 @@ const fn compute_dec_exp(bin_exp: i32, regular: bool) -> i32 {
     (bin_exp * LOG10_2_SIG - !regular as i32 * LOG10_3_OVER_4_SIG) >> LOG10_2_EXP
 }
 
+#[inline]
 const fn do_compute_exp_shift(bin_exp: i32, dec_exp: i32) -> u8 {
     debug_assert!(dec_exp >= -350 && dec_exp <= 350);
     // log2_pow10_sig = round(log2(10) * 2**log2_pow10_exp) + 1
@@ -359,6 +360,7 @@ static EXP_SHIFTS: ExpShiftTable = {
 // 10^dec_exp puts the decimal point in different bit positions:
 //   3 * 2**59 / 100 = 1.72...e+16  (needs shift = 1 + 1)
 //   3 * 2**60 / 100 = 3.45...e+16  (needs shift = 2 + 1)
+#[inline]
 unsafe fn compute_exp_shift<UInt, const ONLY_REGULAR: bool>(bin_exp: i32, dec_exp: i32) -> u8
 where
     UInt: traits::UInt,
@@ -464,29 +466,25 @@ unsafe fn write8(buffer: *mut u8, value: u64) {
     }
 }
 
-// Writes a significand consisting of up to 9 decimal digits (8-9 for normals)
-// and removes trailing zeros.
+// Writes a significand and removes trailing zeros. value has up to 17 decimal
+// digits (16-17 for normals) for double (num_bits == 64) and up to 9 digits
+// (8-9 for normals) for float. The significant digits start from buffer[1].
+// buffer[0] may contain '0' after this function if the leading digit is zero.
 #[cfg_attr(feature = "no-panic", no_panic)]
-unsafe fn write_significand9(mut buffer: *mut u8, value: u32, has9digits: bool) -> *mut u8 {
-    buffer = unsafe { write_if(buffer, value / 100_000_000, has9digits) };
-    let bcd = to_bcd8(u64::from(value % 100_000_000));
-    unsafe {
-        write8(buffer, bcd | ZEROS);
-        buffer.add(count_trailing_nonzeros(bcd))
+#[inline]
+unsafe fn write_significand<Float>(mut buffer: *mut u8, value: u64, extra_digit: bool) -> *mut u8
+where
+    Float: FloatTraits,
+{
+    if Float::NUM_BITS == 32 {
+        buffer = unsafe { write_if(buffer, (value / 100_000_000) as u32, extra_digit) };
+        let bcd = to_bcd8(value % 100_000_000);
+        unsafe {
+            write8(buffer, bcd + ZEROS);
+            return buffer.add(count_trailing_nonzeros(bcd));
+        }
     }
-}
 
-// Writes a significand consisting of up to 17 decimal digits (16-17 for
-// normals) and removes trailing zeros. The significant digits start from
-// buffer[1]. buffer[0] may contain '0' after this function if the significand
-// has length 16.
-#[cfg_attr(feature = "no-panic", no_panic)]
-unsafe fn write_significand17(
-    mut buffer: *mut u8,
-    value: u64,
-    has17digits: bool,
-    #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))] value_div10: i64,
-) -> *mut u8 {
     #[cfg(not(any(
         all(target_arch = "aarch64", target_feature = "neon", not(miri)),
         all(target_arch = "x86_64", target_feature = "sse2", not(miri)),
@@ -495,17 +493,17 @@ unsafe fn write_significand17(
         // Digits/pairs of digits are denoted by letters: value = abbccddeeffgghhii.
         let abbccddee = (value / 100_000_000) as u32;
         let ffgghhii = (value % 100_000_000) as u32;
-        buffer = unsafe { write_if(buffer, abbccddee / 100_000_000, has17digits) };
+        buffer = unsafe { write_if(buffer, abbccddee / 100_000_000, extra_digit) };
         let bcd = to_bcd8(u64::from(abbccddee % 100_000_000));
         unsafe {
-            write8(buffer, bcd | ZEROS);
+            write8(buffer, bcd + ZEROS);
         }
         if ffgghhii == 0 {
             return unsafe { buffer.add(count_trailing_nonzeros(bcd)) };
         }
         let bcd = to_bcd8(u64::from(ffgghhii));
         unsafe {
-            write8(buffer.add(8), bcd | ZEROS);
+            write8(buffer.add(8), bcd + ZEROS);
             buffer.add(8).add(count_trailing_nonzeros(bcd))
         }
     }
@@ -518,14 +516,15 @@ unsafe fn write_significand17(
 
         const NEG10K: i32 = -10000 + 0x10000;
 
-        struct MulConstants {
+        #[repr(C, align(64))]
+        struct Consts {
             mul_const: u64,
             hundred_million: u64,
             multipliers32: int32x4_t,
             multipliers16: int16x8_t,
         }
 
-        static CONSTANTS: MulConstants = MulConstants {
+        static CONSTS: Consts = Consts {
             mul_const: 0xabcc77118461cefd,
             hundred_million: 100000000,
             multipliers32: unsafe {
@@ -541,7 +540,7 @@ unsafe fn write_significand17(
             },
         };
 
-        let mut c = ptr::addr_of!(CONSTANTS);
+        let mut c = ptr::addr_of!(CONSTS);
 
         // Compiler barrier, or clang doesn't load from memory and generates 15
         // more instructions.
@@ -566,7 +565,7 @@ unsafe fn write_significand17(
         let a = (umul128(abbccddee, c.mul_const) >> 90) as u64;
         let bbccddee = abbccddee - a * hundred_million;
 
-        buffer = unsafe { write_if(buffer, a as u32, has17digits) };
+        buffer = unsafe { write_if(buffer, a as u32, extra_digit) };
 
         unsafe {
             let ffgghhii_bbccddee_64: uint64x1_t =
@@ -630,22 +629,15 @@ unsafe fn write_significand17(
     {
         use crate::stdarch_x86::*;
 
-        let last_digit = (value - value_div10 as u64 * 10) as u32;
-
-        // We always write 17 digits into the buffer, but the first one can be
-        // zero. buffer points to the second place in the output buffer to allow
-        // for the insertion of the decimal point, so we can use the first place
-        // as scratch.
-        buffer = unsafe { buffer.offset(isize::from(has17digits) - 1) };
-        unsafe {
-            *buffer.add(16) = last_digit as u8 + b'0';
-        }
+        let abbccddee = (value / 100_000_000) as u32;
+        let ffgghhii = (value % 100_000_000) as u32;
+        let a = abbccddee / 100_000_000;
+        let bbccddee = abbccddee % 100_000_000;
 
-        let abcdefgh = (value_div10 / 100_000_000) as u32;
-        let ijklmnop = (value_div10 % 100_000_000) as u32;
+        buffer = unsafe { write_if(buffer, a, extra_digit) };
 
         #[repr(C, align(64))]
-        struct Constants {
+        struct Consts {
             div10k: u128,
             neg10k: u128,
             div100: u128,
@@ -663,7 +655,7 @@ unsafe fn write_significand17(
             zeros: u128,
         }
 
-        impl Constants {
+        impl Consts {
             const fn splat64(x: u64) -> u128 {
                 ((x as u128) << 64) | x as u128
             }
@@ -689,28 +681,27 @@ unsafe fn write_significand17(
             }
         }
 
-        static CONSTS: Constants = Constants {
-            div10k: Constants::splat64(DIV10K_SIG as u64),
-            neg10k: Constants::splat64(NEG10K as u64),
-            div100: Constants::splat32(DIV100_SIG),
-            div10: Constants::splat16(((1u32 << 16) / 10 + 1) as u16),
+        static CONSTS: Consts = Consts {
+            div10k: Consts::splat64(DIV10K_SIG as u64),
+            neg10k: Consts::splat64(NEG10K as u64),
+            div100: Consts::splat32(DIV100_SIG),
+            div10: Consts::splat16(((1u32 << 16) / 10 + 1) as u16),
             #[cfg(target_feature = "sse4.1")]
-            neg100: Constants::splat32(NEG100),
+            neg100: Consts::splat32(NEG100),
             #[cfg(target_feature = "sse4.1")]
-            neg10: Constants::splat16((1 << 8) - 10),
+            neg10: Consts::splat16((1 << 8) - 10),
             #[cfg(target_feature = "sse4.1")]
-            bswap: Constants::pack8(15, 14, 13, 12, 11, 10, 9, 8) as u128
-                | (Constants::pack8(7, 6, 5, 4, 3, 2, 1, 0) as u128) << 64,
+            bswap: Consts::pack8(15, 14, 13, 12, 11, 10, 9, 8) as u128
+                | (Consts::pack8(7, 6, 5, 4, 3, 2, 1, 0) as u128) << 64,
             #[cfg(not(target_feature = "sse4.1"))]
-            hundred: Constants::splat32(100),
+            hundred: Consts::splat32(100),
             #[cfg(not(target_feature = "sse4.1"))]
-            moddiv10: Constants::splat16(10 * (1 << 8) - 1),
-            zeros: Constants::splat64(ZEROS),
+            moddiv10: Consts::splat16(10 * (1 << 8) - 1),
+            zeros: Consts::splat64(ZEROS),
         };
 
         let mut c = ptr::addr_of!(CONSTS);
-        // Make the compiler forget where the constants came from to ensure they
-        // are loaded from memory.
+        // Load constants from memory.
         unsafe {
             asm!("/*{0}*/", inout(reg) c);
         }
@@ -731,9 +722,9 @@ unsafe fn write_significand17(
         let moddiv10 = unsafe { _mm_load_si128(ptr::addr_of!((*c).moddiv10).cast::<__m128i>()) };
         let zeros = unsafe { _mm_load_si128(ptr::addr_of!((*c).zeros).cast::<__m128i>()) };
 
-        // The BCD sequences are based on the ones provided by Xiang JunBo.
+        // The BCD sequences are based on ones provided by Xiang JunBo.
         unsafe {
-            let x: __m128i = _mm_set_epi64x(i64::from(abcdefgh), i64::from(ijklmnop));
+            let x: __m128i = _mm_set_epi64x(i64::from(bbccddee), i64::from(ffgghhii));
             let y: __m128i = _mm_add_epi64(
                 x,
                 _mm_mul_epu32(neg10k, _mm_srli_epi64(_mm_mul_epu32(x, div10k), DIV10K_EXP)),
@@ -769,15 +760,10 @@ unsafe fn write_significand17(
             // Count leading zeros.
             let mask128: __m128i = _mm_cmpgt_epi8(bcd, _mm_setzero_si128());
             let mask = _mm_movemask_epi8(mask128) as u32;
-            // We don't need a zero-check here: if the mask were zero, either
-            // the significand is zero which is handled elsewhere or the only
-            // non-zero digit is the last digit which we factored off. But in
-            // that case the number would be printed with a different exponent
-            // that shifts the last digit into the first position.
             let len = 32 - mask.leading_zeros() as usize;
 
             _mm_storeu_si128(buffer.cast::<__m128i>(), digits);
-            buffer.add(if last_digit != 0 { 17 } else { len })
+            buffer.add(len)
         }
     }
 }
@@ -785,11 +771,10 @@ unsafe fn write_significand17(
 struct ToDecimalResult {
     sig: i64,
     exp: i32,
-    #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-    sig_div10: i64,
 }
 
 #[cfg_attr(feature = "no-panic", no_panic)]
+#[inline]
 fn to_decimal_schubfach<UInt>(bin_sig: UInt, bin_exp: i64, regular: bool) -> ToDecimalResult
 where
     UInt: traits::UInt,
@@ -824,13 +809,10 @@ where
     let div10 = (upper >> BOUND_SHIFT) / UInt::from(10);
     let shorter = div10 * UInt::from(10);
     if (shorter << BOUND_SHIFT) >= lower {
-        let result = ToDecimalResult {
+        return ToDecimalResult {
             sig: shorter.into() as i64,
             exp: dec_exp,
-            #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-            sig_div10: div10.into() as i64,
         };
-        return result;
     }
 
     let scaled_sig = umulhi_inexact_to_odd(pow10.hi, pow10.lo, bin_sig_shifted << exp_shift);
@@ -853,8 +835,6 @@ where
     ToDecimalResult {
         sig: dec_sig.into() as i64,
         exp: dec_exp,
-        #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-        sig_div10: (dec_sig / UInt::from(10)).into() as i64,
     }
 }
 
@@ -862,6 +842,7 @@ where
 // Converts a binary FP number bin_sig * 2**bin_exp to the shortest decimal
 // representation, where bin_exp = raw_exp - exp_offset.
 #[cfg_attr(feature = "no-panic", no_panic)]
+#[inline]
 fn to_decimal_fast<Float, UInt>(bin_sig: UInt, raw_exp: i64, regular: bool) -> ToDecimalResult
 where
     Float: FloatTraits,
@@ -966,8 +947,6 @@ where
             return ToDecimalResult {
                 sig: hint::select_unpredictable(round_up, shorter + 10, dec_sig),
                 exp: dec_exp,
-                #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-                sig_div10: 0,
             };
         }
         shorter += i64::from(round_up) * 10;
@@ -975,8 +954,6 @@ where
         return ToDecimalResult {
             sig: hint::select_unpredictable(use_shorter, shorter, longer),
             exp: dec_exp,
-            #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-            sig_div10: div10 as i64 + i64::from(use_shorter) * i64::from(round_up),
         };
     }
     to_decimal_schubfach(bin_sig, bin_exp, regular)
@@ -1019,10 +996,6 @@ where
             dec.sig *= 10;
             dec.exp -= 1;
         }
-        #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-        {
-            dec.sig_div10 = dec.sig / 10;
-        }
     } else {
         dec = to_decimal_fast::<Float, Float::SigType>(
             bin_sig | Float::IMPLICIT_BIT,
@@ -1039,19 +1012,7 @@ where
     }
 
     // Write significand.
-    let end = if Float::NUM_BITS == 64 {
-        unsafe {
-            write_significand17(
-                buffer.add(1),
-                dec.sig as u64,
-                extra_digit,
-                #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-                dec.sig_div10,
-            )
-        }
-    } else {
-        unsafe { write_significand9(buffer.add(1), dec.sig as u32, extra_digit) }
-    };
+    let end = unsafe { write_significand::<Float>(buffer.add(1), dec.sig as u64, extra_digit) };
 
     let length = unsafe { end.offset_from(buffer.add(1)) } as usize;