Run the formatter

diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 9f30847d..86eeabcc 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1564,7 +1564,7 @@ impl<'a> Arbitrary<'a> for TapSighashType {
 }
 
 #[cfg(feature = "arbitrary")]
-impl<'a, T> Arbitrary<'a> for SighashCache<T> 
+impl<'a, T> Arbitrary<'a> for SighashCache<T>
 where
     T: Borrow<Transaction> + Arbitrary<'a>,
 {
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index abbd1b32..997df310 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -20,10 +20,11 @@ use crate::network::Params;
 #[doc(inline)]
 pub use primitives::pow::{error, CompactTarget, CompactTargetEncoder, CompactTargetDecoder, Target, Work};
 #[doc(no_inline)]
-pub use self::error::CompactTargetDecoderError;
-#[doc(no_inline)]
 pub use primitives::pow::{ParseTargetError, ParseWorkError};
 
+#[doc(no_inline)]
+pub use self::error::CompactTargetDecoderError;
+
 /// Extension functionality for the [`Work`] type.
 // This can't be defined with the extension trait macro because it ignores the feature gate.
 pub trait WorkExt {
diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
index f1c81aae..071762c6 100644
--- a/bitcoin/tests/serde.rs
+++ b/bitcoin/tests/serde.rs
@@ -31,8 +31,7 @@ use bitcoin::taproot::{self, ControlBlock, LeafVersion, TapTree, TaprootBuilder}
 use bitcoin::witness::Witness;
 use bitcoin::{
     ecdsa, hex, transaction, Address, Amount, LegacyPublicKey, NetworkKind, OutPoint,
-    ScriptPubKeyBuf, ScriptSigBuf, Sequence, TapScriptBuf, Transaction, TxIn, TxOut, Txid,
-    WifKey,
+    ScriptPubKeyBuf, ScriptSigBuf, Sequence, TapScriptBuf, Transaction, TxIn, TxOut, Txid, WifKey,
 };
 
 #[test]
diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_psbt.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_psbt.rs
index 2cc5ce16..f4f37673 100644
--- a/fuzz/fuzz_targets/bitcoin/arbitrary_psbt.rs
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_psbt.rs
@@ -1,10 +1,10 @@
 #![cfg_attr(fuzzing, no_main)]
 #![cfg_attr(not(fuzzing), allow(unused))]
 
-use libfuzzer_sys::fuzz_target;
 use arbitrary::{Arbitrary, Unstructured};
-
-use bitcoin::{FeeRate, Psbt, Transaction, bip32::Xpriv};
+use bitcoin::bip32::Xpriv;
+use bitcoin::{FeeRate, Psbt, Transaction};
+use libfuzzer_sys::fuzz_target;
 
 #[cfg(not(fuzzing))]
 fn main() {}
@@ -14,7 +14,6 @@ fn do_test(data: &[u8]) {
     let p = Psbt::arbitrary(&mut u);
 
     if let Ok(mut psbt) = p {
-
         if let Ok(tx) = Transaction::arbitrary(&mut u) {
             let _ = Psbt::from_unsigned_tx(tx);
         }
diff --git a/hashes/src/sha256/crypto/arm_sha2.rs b/hashes/src/sha256/crypto/arm_sha2.rs
index 535dee40..0212e116 100644
--- a/hashes/src/sha256/crypto/arm_sha2.rs
+++ b/hashes/src/sha256/crypto/arm_sha2.rs
@@ -944,4 +944,3 @@ pub(super) unsafe fn sha256d_64_2way(output: &mut [[u8; 32]; 2], input: &[[u8; 6
     vst1q_u8(output[1].as_mut_ptr().add(0), vrev32q_u8(vreinterpretq_u8_u32(state0_b)));
     vst1q_u8(output[1].as_mut_ptr().add(16), vrev32q_u8(vreinterpretq_u8_u32(state1_b)));
 }
-
diff --git a/hashes/src/sha256/crypto/mod.rs b/hashes/src/sha256/crypto/mod.rs
index a4c239e6..6bd44d5f 100644
--- a/hashes/src/sha256/crypto/mod.rs
+++ b/hashes/src/sha256/crypto/mod.rs
@@ -5,7 +5,6 @@
 #![allow(clippy::too_many_lines)]
 #![allow(clippy::many_single_char_names)]
 
-
 #[cfg(target_arch = "aarch64")]
 #[cfg(any(feature = "cpufeatures", feature = "std"))]
 mod arm_sha2;
diff --git a/hashes/src/sha256/crypto/x86_shani.rs b/hashes/src/sha256/crypto/x86_shani.rs
index 71944c1a..9936b7d5 100644
--- a/hashes/src/sha256/crypto/x86_shani.rs
+++ b/hashes/src/sha256/crypto/x86_shani.rs
@@ -336,10 +336,8 @@ pub(super) unsafe fn sha256d_64_2way(output: &mut [[u8; 32]; 2], input: &[[u8; 6
     const FINAL: [u32; 8] = [0x80000000, 0, 0, 0, 0, 0, 0, 0x100];
 
     #[allow(non_snake_case)]
-    let MASK: __m128i = _mm_set_epi64x(
-        0x0c0d_0e0f_0809_0a0bu64 as i64,
-        0x0405_0607_0001_0203u64 as i64,
-    );
+    let MASK: __m128i =
+        _mm_set_epi64x(0x0c0d_0e0f_0809_0a0bu64 as i64, 0x0405_0607_0001_0203u64 as i64);
 
     // Preshuffled SHA256 initial hash values for x86 SHA-NI.
     let init0: __m128i = _mm_set_epi64x(0x6a09e667bb67ae85u64 as i64, 0x510e527f9b05688cu64 as i64);
@@ -1101,9 +1099,20 @@ pub(super) unsafe fn sha256d_64_2way(output: &mut [[u8; 32]; 2], input: &[[u8; 6
 
     // Store results (byte-swap to big-endian)
     // CAST SAFETY: storeu_si128 does not require alignment.
-    _mm_storeu_si128(output[0].as_mut_ptr().add(0).cast::<__m128i>(), _mm_shuffle_epi8(state0_a, MASK));
-    _mm_storeu_si128(output[0].as_mut_ptr().add(16).cast::<__m128i>(), _mm_shuffle_epi8(state1_a, MASK));
-    _mm_storeu_si128(output[1].as_mut_ptr().add(0).cast::<__m128i>(), _mm_shuffle_epi8(state0_b, MASK));
-    _mm_storeu_si128(output[1].as_mut_ptr().add(16).cast::<__m128i>(), _mm_shuffle_epi8(state1_b, MASK));
+    _mm_storeu_si128(
+        output[0].as_mut_ptr().add(0).cast::<__m128i>(),
+        _mm_shuffle_epi8(state0_a, MASK),
+    );
+    _mm_storeu_si128(
+        output[0].as_mut_ptr().add(16).cast::<__m128i>(),
+        _mm_shuffle_epi8(state1_a, MASK),
+    );
+    _mm_storeu_si128(
+        output[1].as_mut_ptr().add(0).cast::<__m128i>(),
+        _mm_shuffle_epi8(state0_b, MASK),
+    );
+    _mm_storeu_si128(
+        output[1].as_mut_ptr().add(16).cast::<__m128i>(),
+        _mm_shuffle_epi8(state1_b, MASK),
+    );
 }
-
diff --git a/units/src/locktime/relative/error.rs b/units/src/locktime/relative/error.rs
index f5ddbcd9..baf31637 100644
--- a/units/src/locktime/relative/error.rs
+++ b/units/src/locktime/relative/error.rs
@@ -145,7 +145,6 @@ impl fmt::Display for IsSatisfiedByTimeError {
         match *self {
             Self::Satisfaction(ref e) => write_err!(f, "satisfaction"; e),
             Self::Incompatible(ref e) => write_err!(f, "incompatible"; e),
-
         }
     }
 }
diff --git a/units/src/locktime/relative/mod.rs b/units/src/locktime/relative/mod.rs
index dde79d7a..afeac947 100644
--- a/units/src/locktime/relative/mod.rs
+++ b/units/src/locktime/relative/mod.rs
@@ -237,7 +237,8 @@ impl LockTime {
             Self::Blocks(blocks) => blocks
                 .is_satisfied_by(chain_tip, utxo_mined_at)
                 .map_err(IsSatisfiedByHeightError::Satisfaction),
-            Self::Time(time) => Err(IsSatisfiedByHeightError::Incompatible(IncompatibleHeightError(time))),
+            Self::Time(time) =>
+                Err(IsSatisfiedByHeightError::Incompatible(IncompatibleHeightError(time))),
         }
     }
 
@@ -259,7 +260,8 @@ impl LockTime {
             Self::Time(time) => time
                 .is_satisfied_by(chain_tip, utxo_mined_at)
                 .map_err(IsSatisfiedByTimeError::Satisfaction),
-            Self::Blocks(blocks) => Err(IsSatisfiedByTimeError::Incompatible(IncompatibleTimeError(blocks))),
+            Self::Blocks(blocks) =>
+                Err(IsSatisfiedByTimeError::Incompatible(IncompatibleTimeError(blocks))),
         }
     }
 
@@ -839,7 +841,10 @@ mod tests {
         let err = lock_by_time.is_satisfied_by_height(chain_tip, mined_at).unwrap_err();
 
         let expected_time = NumberOf512Seconds::from_512_second_intervals(70);
-        assert_eq!(err, IsSatisfiedByHeightError::Incompatible(IncompatibleHeightError(expected_time)));
+        assert_eq!(
+            err,
+            IsSatisfiedByHeightError::Incompatible(IncompatibleHeightError(expected_time))
+        );
         assert!(!format!("{}", err).is_empty());
     }
 
@@ -867,7 +872,10 @@ mod tests {
         let err = lock_by_height.is_satisfied_by_time(chain_tip, mined_at).unwrap_err();
 
         let expected_height = NumberOfBlocks::from(10);
-        assert_eq!(err, IsSatisfiedByTimeError::Incompatible(IncompatibleTimeError(expected_height)));
+        assert_eq!(
+            err,
+            IsSatisfiedByTimeError::Incompatible(IncompatibleTimeError(expected_height))
+        );
         assert!(!format!("{}", err).is_empty());
     }
 
diff --git a/units/tests/serde.rs b/units/tests/serde.rs
index aa20f059..a7d7324c 100644
--- a/units/tests/serde.rs
+++ b/units/tests/serde.rs
@@ -96,7 +96,7 @@ impl Serde {
             rel_locktime: RelativeLockTime::Blocks(NumberOfBlocks::MAX),
 
             target: Target::MAX_ATTAINABLE_MAINNET,
-            work: Target::MAX_ATTAINABLE_MAINNET.to_work()
+            work: Target::MAX_ATTAINABLE_MAINNET.to_work(),
         }
     }
 }