Informational 15 Bitcoin Committed Jul 3, 2026 · 15:49 UTC
ci: regenerate api snapshots

edca8ec9 View source ↗
Public commit record
What the developer wrote

Authored by satsfy (Renato Britto)
70/100 · Adequate
ci: regenerate api snapshots

cargo-rbmt 0.4.0 changed the snapshot format so trait items carry an
`[impl: ...]` annotation naming the impl block they come from.

The nightly bump to nightly-2026-06-19 changed the rustdoc output for
derived `StructuralPartialEq` impls on generic types, which now print the
`PartialEq` bound.

This commit regenerates the api snapshots so the check passes.
✓ Descriptive subject✓ Uses a recognizable type or scope✓ Provides detailed explanatory context
The short version
What changed, and why it matters

This commit is a routine maintenance update for the project's automated API snapshot tests. It does not change any actual library code, behavior, or functionality. The changes only update the expected test output files (snapshots) so they match the format produced by newer versions of the testing tools and the Rust compiler. There is no security impact.
Recommended action
No action required. This is a benign CI/test snapshot regeneration.
Security signals we found

No strong security signals were identified.
Technical analysis
Evidence from the diff

The commit regenerates 18 public API snapshot files under */api/ directories. The diffs are purely formatting changes in the snapshot text: trait items now carry an [impl: ...] annotation due to cargo-rbmt 0.4.0, and derived StructuralPartialEq impls on generic types now print the PartialEq bound due to the nightly-2026-06-19 rustdoc output. No source code, logic, or public API surface was modified.
Changed components

consensus_encoding/api/*.txthashes/api/*.txtinternals/api/*.txtnetwork/api/*.txtprimitives/api/*.txtunits/api/*.txt
Inspect captured patch +44454 / −15345
diff --git a/consensus_encoding/api/all-features.txt b/consensus_encoding/api/all-features.txt
index 277f9814..2d5c2431 100644
--- a/consensus_encoding/api/all-features.txt
+++ b/consensus_encoding/api/all-features.txt
@@ -6,18 +6,19 @@ pub enum bitcoin_consensus_encoding::error::DecodeError<Err>
 pub bitcoin_consensus_encoding::error::DecodeError::Parse(Err)
 pub bitcoin_consensus_encoding::error::DecodeError::Unconsumed(bitcoin_consensus_encoding::error::UnconsumedError)
 impl<Err: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::DecodeError<Err>
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone(&self) -> bitcoin_consensus_encoding::error::DecodeError<Err>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone(&self) -> bitcoin_consensus_encoding::error::DecodeError<Err> [impl: impl<Err: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::DecodeError<Err>]
 impl<Err: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::DecodeError<Err>
 impl<Err: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::DecodeError<Err>
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::eq(&self, other: &bitcoin_consensus_encoding::error::DecodeError<Err>) -> bool
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::eq(&self, other: &bitcoin_consensus_encoding::error::DecodeError<Err>) -> bool [impl: impl<Err: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::DecodeError<Err>]
+impl<Err: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::DecodeError<Err>
 impl<Err: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::DecodeError<Err>
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<Err: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::DecodeError<Err>]
 impl<Err> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::DecodeError<Err>
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::from(never: core::convert::Infallible) -> Self
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::from(never: core::convert::Infallible) -> Self [impl: impl<Err> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::DecodeError<Err>]
 impl<Err> core::error::Error for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::error::Error + 'static
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<Err> core::error::Error for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::error::Error + 'static]
 impl<Err> core::fmt::Display for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::fmt::Display
-impl<Err> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::DecodeError<Err>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<Err> core::fmt::Display for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::fmt::Display]
 impl<Err> core::marker::Freeze for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::marker::Freeze
 impl<Err> core::marker::Send for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::marker::Send
 impl<Err> core::marker::Sync for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::marker::Sync
@@ -26,43 +27,44 @@ impl<Err> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::Decod
 impl<Err> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::panic::unwind_safe::RefUnwindSafe
 impl<Err> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::panic::unwind_safe::UnwindSafe
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Owned = T
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::DecodeError<Err> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::DecodeError<Err> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::DecodeError<Err> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::DecodeError<Err> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::DecodeError<Err> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::DecodeError<Err> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::DecodeError<Err>
-pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::DecodeError<Err>]
 pub enum bitcoin_consensus_encoding::error::Decoder2Error<A, B>
 pub bitcoin_consensus_encoding::error::Decoder2Error::First(A)
 pub bitcoin_consensus_encoding::error::Decoder2Error::Second(B)
 impl<A, B> core::error::Error for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::error::Error + 'static, B: core::error::Error + 'static
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<A, B> core::error::Error for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::error::Error + 'static, B: core::error::Error + 'static]
 impl<A, B> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::fmt::Display, B: core::fmt::Display
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-impl<A, B> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A, B> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::fmt::Display, B: core::fmt::Display]
 impl<A: core::clone::Clone, B: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder2Error<A, B> [impl: impl<A: core::clone::Clone, B: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder2Error<A, B>]
 impl<A: core::cmp::Eq, B: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
 impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder2Error<A, B>) -> bool
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder2Error<A, B>) -> bool [impl: impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>]
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
 impl<A: core::fmt::Debug, B: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A: core::fmt::Debug, B: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder2Error<A, B>]
 impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::marker::Freeze, B: core::marker::Freeze
 impl<A, B> core::marker::Send for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::marker::Send, B: core::marker::Send
 impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::marker::Sync, B: core::marker::Sync
@@ -71,44 +73,45 @@ impl<A, B> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::Deco
 impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
 impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Owned = T
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
-pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B>]
 pub enum bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
 pub bitcoin_consensus_encoding::error::Decoder3Error::First(A)
 pub bitcoin_consensus_encoding::error::Decoder3Error::Second(B)
 pub bitcoin_consensus_encoding::error::Decoder3Error::Third(C)
 impl<A, B, C> core::error::Error for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<A, B, C> core::error::Error for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static]
 impl<A, B, C> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-impl<A, B, C> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A, B, C> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display]
 impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> [impl: impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>]
 impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
 impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>) -> bool
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>) -> bool [impl: impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>]
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
 impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>]
 impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze
 impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send
 impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync
@@ -117,45 +120,46 @@ impl<A, B, C> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::D
 impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe
 impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Owned = T
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
-pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>]
 pub enum bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
 pub bitcoin_consensus_encoding::error::Decoder4Error::First(A)
 pub bitcoin_consensus_encoding::error::Decoder4Error::Fourth(D)
 pub bitcoin_consensus_encoding::error::Decoder4Error::Second(B)
 pub bitcoin_consensus_encoding::error::Decoder4Error::Third(C)
 impl<A, B, C, D> core::error::Error for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<A, B, C, D> core::error::Error for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static]
 impl<A, B, C, D> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-impl<A, B, C, D> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A, B, C, D> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display]
 impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> [impl: impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>]
 impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
 impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>) -> bool
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>) -> bool [impl: impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>]
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
 impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>]
 impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze
 impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send
 impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync
@@ -164,29 +168,29 @@ impl<A, B, C, D> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error
 impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe
 impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Owned = T
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
-pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>]
 pub enum bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
 pub bitcoin_consensus_encoding::error::Decoder6Error::Fifth(E)
 pub bitcoin_consensus_encoding::error::Decoder6Error::First(A)
@@ -195,16 +199,17 @@ pub bitcoin_consensus_encoding::error::Decoder6Error::Second(B)
 pub bitcoin_consensus_encoding::error::Decoder6Error::Sixth(F)
 pub bitcoin_consensus_encoding::error::Decoder6Error::Third(C)
 impl<A, B, C, D, E, F> core::error::Error for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static, E: core::error::Error + 'static, F: core::error::Error + 'static
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<A, B, C, D, E, F> core::error::Error for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static, E: core::error::Error + 'static, F: core::error::Error + 'static]
 impl<A, B, C, D, E, F> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display, E: core::fmt::Display, F: core::fmt::Display
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-impl<A, B, C, D, E, F> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A, B, C, D, E, F> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display, E: core::fmt::Display, F: core::fmt::Display]
 impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone, E: core::clone::Clone, F: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> [impl: impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone, E: core::clone::Clone, F: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>]
 impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq, E: core::cmp::Eq, F: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
 impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>) -> bool
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>) -> bool [impl: impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>]
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
 impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug, E: core::fmt::Debug, F: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug, E: core::fmt::Debug, F: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>]
 impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze, F: core::marker::Freeze
 impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send, E: core::marker::Send, F: core::marker::Send
 impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync, F: core::marker::Sync
@@ -213,39 +218,40 @@ impl<A, B, C, D, E, F> core::marker::UnsafeUnpin for bitcoin_consensus_encoding:
 impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe
 impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Owned = T
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
-pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>]
 pub enum bitcoin_consensus_encoding::error::ReadError<D>
 pub bitcoin_consensus_encoding::error::ReadError::Decode(D)
 pub bitcoin_consensus_encoding::error::ReadError::Io(std::io::error::Error)
 impl<D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::ReadError<D>
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::ReadError<D>]
 impl<D: core::fmt::Display> core::fmt::Display for bitcoin_consensus_encoding::error::ReadError<D>
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<D: core::fmt::Display> core::fmt::Display for bitcoin_consensus_encoding::error::ReadError<D>]
 impl<D> core::convert::From<std::io::error::Error> for bitcoin_consensus_encoding::error::ReadError<D>
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::from(e: std::io::error::Error) -> Self
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::from(e: std::io::error::Error) -> Self [impl: impl<D> core::convert::From<std::io::error::Error> for bitcoin_consensus_encoding::error::ReadError<D>]
 impl<D> core::error::Error for bitcoin_consensus_encoding::error::ReadError<D> where D: core::error::Error + 'static
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<D> core::error::Error for bitcoin_consensus_encoding::error::ReadError<D> where D: core::error::Error + 'static]
 impl<D> core::marker::Freeze for bitcoin_consensus_encoding::error::ReadError<D> where D: core::marker::Freeze
 impl<D> core::marker::Send for bitcoin_consensus_encoding::error::ReadError<D> where D: core::marker::Send
 impl<D> core::marker::Sync for bitcoin_consensus_encoding::error::ReadError<D> where D: core::marker::Sync
@@ -254,36 +260,37 @@ impl<D> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::ReadErr
 impl<D> !core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::ReadError<D>
 impl<D> !core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::ReadError<D>
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::ReadError<D>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::ReadError<D>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::ReadError<D>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::ReadError<D>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::TryFrom<T>]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::ReadError<D> where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::ReadError<D> where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::ReadError<D> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::ReadError<D> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::ReadError<D> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::ReadError<D> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::ReadError<D> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::ReadError<D> where T: ?core::marker::Sized]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::ReadError<D>
-pub fn bitcoin_consensus_encoding::error::ReadError<D>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::ReadError<D>]
 pub struct bitcoin_consensus_encoding::error::ByteVecDecoderError(_)
 impl core::clone::Clone for bitcoin_consensus_encoding::error::ByteVecDecoderError
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone(&self) -> bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone(&self) -> bitcoin_consensus_encoding::error::ByteVecDecoderError [impl: impl core::clone::Clone for bitcoin_consensus_encoding::error::ByteVecDecoderError]
 impl core::cmp::Eq for bitcoin_consensus_encoding::error::ByteVecDecoderError
 impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::ByteVecDecoderError
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::eq(&self, other: &bitcoin_consensus_encoding::error::ByteVecDecoderError) -> bool
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::eq(&self, other: &bitcoin_consensus_encoding::error::ByteVecDecoderError) -> bool [impl: impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::ByteVecDecoderError]
 impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::ByteVecDecoderError
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::from(never: core::convert::Infallible) -> Self
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::from(never: core::convert::Infallible) -> Self [impl: impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::ByteVecDecoderError]
 impl core::error::Error for bitcoin_consensus_encoding::error::ByteVecDecoderError
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl core::error::Error for bitcoin_consensus_encoding::error::ByteVecDecoderError]
 impl core::fmt::Debug for bitcoin_consensus_encoding::error::ByteVecDecoderError
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::error::ByteVecDecoderError]
 impl core::fmt::Display for bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Display for bitcoin_consensus_encoding::error::ByteVecDecoderError]
 impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::ByteVecDecoderError
 impl core::marker::Freeze for bitcoin_consensus_encoding::error::ByteVecDecoderError
 impl core::marker::Send for bitcoin_consensus_encoding::error::ByteVecDecoderError
@@ -293,42 +300,43 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::ByteVecDec
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::ByteVecDecoderError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::ByteVecDecoderError
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Owned = T
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError
-pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError]
 pub struct bitcoin_consensus_encoding::error::CompactSizeDecoderError(_)
 impl core::clone::Clone for bitcoin_consensus_encoding::error::CompactSizeDecoderError
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::clone(&self) -> bitcoin_consensus_encoding::error::CompactSizeDecoderError
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::clone(&self) -> bitcoin_consensus_encoding::error::CompactSizeDecoderError [impl: impl core::clone::Clone for bitcoin_consensus_encoding::error::CompactSizeDecoderError]
 impl core::cmp::Eq for bitcoin_consensus_encoding::error::CompactSizeDecoderError
 impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::CompactSizeDecoderError
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::eq(&self, other: &bitcoin_consensus_encoding::error::CompactSizeDecoderError) -> bool
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::eq(&self, other: &bitcoin_consensus_encoding::error::CompactSizeDecoderError) -> bool [impl: impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::CompactSizeDecoderError]
 impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::CompactSizeDecoderError
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::from(never: core::convert::Infallible) -> Self
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::from(never: core::convert::Infallible) -> Self [impl: impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::CompactSizeDecoderError]
 impl core::error::Error for bitcoin_consensus_encoding::error::CompactSizeDecoderError
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl core::error::Error for bitcoin_consensus_encoding::error::CompactSizeDecoderError]
 impl core::fmt::Debug for bitcoin_consensus_encoding::error::CompactSizeDecoderError
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::error::CompactSizeDecoderError]
 impl core::fmt::Display for bitcoin_consensus_encoding::error::CompactSizeDecoderError
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Display for bitcoin_consensus_encoding::error::CompactSizeDecoderError]
 impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::CompactSizeDecoderError
 impl core::marker::Freeze for bitcoin_consensus_encoding::error::CompactSizeDecoderError
 impl core::marker::Send for bitcoin_consensus_encoding::error::CompactSizeDecoderError
@@ -338,43 +346,44 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::CompactSiz
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::CompactSizeDecoderError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::CompactSizeDecoderError
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::CompactSizeDecoderError::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::CompactSizeDecoderError::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::CompactSizeDecoderError::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::CompactSizeDecoderError::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::CompactSizeDecoderError::Owned = T
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::CompactSizeDecoderError::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::CompactSizeDecoderError where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::CompactSizeDecoderError
-pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::CompactSizeDecoderError::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::CompactSizeDecoderError]
 pub struct bitcoin_consensus_encoding::error::FromHexError<ParseErr>(_)
 impl<ParseErr: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::clone(&self) -> bitcoin_consensus_encoding::error::FromHexError<ParseErr>
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::clone(&self) -> bitcoin_consensus_encoding::error::FromHexError<ParseErr> [impl: impl<ParseErr: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::FromHexError<ParseErr>]
 impl<ParseErr: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
 impl<ParseErr: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::eq(&self, other: &bitcoin_consensus_encoding::error::FromHexError<ParseErr>) -> bool
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::eq(&self, other: &bitcoin_consensus_encoding::error::FromHexError<ParseErr>) -> bool [impl: impl<ParseErr: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::FromHexError<ParseErr>]
+impl<ParseErr: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
 impl<ParseErr: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<ParseErr: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::FromHexError<ParseErr>]
 impl<ParseErr: core::fmt::Display> core::fmt::Display for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<ParseErr: core::fmt::Display> core::fmt::Display for bitcoin_consensus_encoding::error::FromHexError<ParseErr>]
 impl<ParseErr> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::from(never: core::convert::Infallible) -> Self
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::from(never: core::convert::Infallible) -> Self [impl: impl<ParseErr> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::FromHexError<ParseErr>]
 impl<ParseErr> core::error::Error for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where ParseErr: core::error::Error + 'static
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-impl<ParseErr> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<ParseErr> core::error::Error for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where ParseErr: core::error::Error + 'static]
 impl<ParseErr> core::marker::Freeze for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where ParseErr: core::marker::Freeze
 impl<ParseErr> core::marker::Send for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where ParseErr: core::marker::Send
 impl<ParseErr> core::marker::Sync for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where ParseErr: core::marker::Sync
@@ -383,42 +392,43 @@ impl<ParseErr> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::
 impl<ParseErr> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where ParseErr: core::panic::unwind_safe::RefUnwindSafe
 impl<ParseErr> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where ParseErr: core::panic::unwind_safe::UnwindSafe
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::FromHexError<ParseErr>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::FromHexError<ParseErr>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::FromHexError<ParseErr>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::FromHexError<ParseErr>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::FromHexError<ParseErr>::Owned = T
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::FromHexError<ParseErr>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::FromHexError<ParseErr> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::FromHexError<ParseErr>
-pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::FromHexError<ParseErr>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::FromHexError<ParseErr>]
 pub struct bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
 impl core::clone::Clone for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::clone(&self) -> bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::clone(&self) -> bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError [impl: impl core::clone::Clone for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError]
 impl core::cmp::Eq for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
 impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::eq(&self, other: &bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError) -> bool
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::eq(&self, other: &bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError) -> bool [impl: impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError]
 impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::from(never: core::convert::Infallible) -> Self
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::from(never: core::convert::Infallible) -> Self [impl: impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError]
 impl core::error::Error for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl core::error::Error for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError]
 impl core::fmt::Debug for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError]
 impl core::fmt::Display for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Display for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError]
 impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
 impl core::marker::Freeze for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
 impl core::marker::Send for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
@@ -428,42 +438,43 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::LengthPref
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::Owned = T
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError
-pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::LengthPrefixExceedsMaxError]
 pub struct bitcoin_consensus_encoding::error::UnconsumedError()
 impl core::clone::Clone for bitcoin_consensus_encoding::error::UnconsumedError
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::clone(&self) -> bitcoin_consensus_encoding::error::UnconsumedError
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::clone(&self) -> bitcoin_consensus_encoding::error::UnconsumedError [impl: impl core::clone::Clone for bitcoin_consensus_encoding::error::UnconsumedError]
 impl core::cmp::Eq for bitcoin_consensus_encoding::error::UnconsumedError
 impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::UnconsumedError
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::eq(&self, other: &bitcoin_consensus_encoding::error::UnconsumedError) -> bool
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::eq(&self, other: &bitcoin_consensus_encoding::error::UnconsumedError) -> bool [impl: impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::UnconsumedError]
 impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::UnconsumedError
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::from(never: core::convert::Infallible) -> Self
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::from(never: core::convert::Infallible) -> Self [impl: impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::UnconsumedError]
 impl core::error::Error for bitcoin_consensus_encoding::error::UnconsumedError
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl core::error::Error for bitcoin_consensus_encoding::error::UnconsumedError]
 impl core::fmt::Debug for bitcoin_consensus_encoding::error::UnconsumedError
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::error::UnconsumedError]
 impl core::fmt::Display for bitcoin_consensus_encoding::error::UnconsumedError
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Display for bitcoin_consensus_encoding::error::UnconsumedError]
 impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::UnconsumedError
 impl core::marker::Freeze for bitcoin_consensus_encoding::error::UnconsumedError
 impl core::marker::Send for bitcoin_consensus_encoding::error::UnconsumedError
@@ -473,42 +484,43 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::Unconsumed
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::UnconsumedError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::UnconsumedError
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::UnconsumedError where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::UnconsumedError where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::UnconsumedError where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::UnconsumedError::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::UnconsumedError::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::UnconsumedError where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::UnconsumedError where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::UnconsumedError where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::UnconsumedError::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::UnconsumedError::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::UnconsumedError where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::UnconsumedError where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::UnconsumedError where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::UnconsumedError::Owned = T
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::UnconsumedError::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::UnconsumedError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::UnconsumedError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::UnconsumedError where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::UnconsumedError where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::UnconsumedError where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::UnconsumedError where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::UnconsumedError where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::UnconsumedError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::UnconsumedError where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::UnconsumedError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::UnconsumedError where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::UnconsumedError where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::UnconsumedError::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::UnconsumedError::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::UnconsumedError where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::UnconsumedError
-pub fn bitcoin_consensus_encoding::error::UnconsumedError::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::UnconsumedError::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::UnconsumedError]
 pub struct bitcoin_consensus_encoding::error::UnexpectedEofError
 impl core::clone::Clone for bitcoin_consensus_encoding::error::UnexpectedEofError
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::clone(&self) -> bitcoin_consensus_encoding::error::UnexpectedEofError
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::clone(&self) -> bitcoin_consensus_encoding::error::UnexpectedEofError [impl: impl core::clone::Clone for bitcoin_consensus_encoding::error::UnexpectedEofError]
 impl core::cmp::Eq for bitcoin_consensus_encoding::error::UnexpectedEofError
 impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::UnexpectedEofError
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::eq(&self, other: &bitcoin_consensus_encoding::error::UnexpectedEofError) -> bool
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::eq(&self, other: &bitcoin_consensus_encoding::error::UnexpectedEofError) -> bool [impl: impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::UnexpectedEofError]
 impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::UnexpectedEofError
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::from(never: core::convert::Infallible) -> Self
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::from(never: core::convert::Infallible) -> Self [impl: impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::UnexpectedEofError]
 impl core::error::Error for bitcoin_consensus_encoding::error::UnexpectedEofError
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl core::error::Error for bitcoin_consensus_encoding::error::UnexpectedEofError]
 impl core::fmt::Debug for bitcoin_consensus_encoding::error::UnexpectedEofError
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::error::UnexpectedEofError]
 impl core::fmt::Display for bitcoin_consensus_encoding::error::UnexpectedEofError
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Display for bitcoin_consensus_encoding::error::UnexpectedEofError]
 impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::UnexpectedEofError
 impl core::marker::Freeze for bitcoin_consensus_encoding::error::UnexpectedEofError
 impl core::marker::Send for bitcoin_consensus_encoding::error::UnexpectedEofError
@@ -518,43 +530,44 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::Unexpected
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::UnexpectedEofError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::UnexpectedEofError
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::UnexpectedEofError where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::UnexpectedEofError where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::UnexpectedEofError where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::UnexpectedEofError::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::UnexpectedEofError::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::UnexpectedEofError where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::UnexpectedEofError where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::UnexpectedEofError where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::UnexpectedEofError::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::UnexpectedEofError::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::UnexpectedEofError where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::UnexpectedEofError where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::UnexpectedEofError where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::UnexpectedEofError::Owned = T
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::UnexpectedEofError::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::UnexpectedEofError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::UnexpectedEofError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::UnexpectedEofError where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::UnexpectedEofError where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::UnexpectedEofError where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::UnexpectedEofError where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::UnexpectedEofError where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::UnexpectedEofError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::UnexpectedEofError where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::UnexpectedEofError where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::UnexpectedEofError where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::UnexpectedEofError where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::UnexpectedEofError::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::UnexpectedEofError::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::UnexpectedEofError where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::UnexpectedEofError
-pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::UnexpectedEofError::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::UnexpectedEofError]
 pub struct bitcoin_consensus_encoding::error::VecDecoderError<Err>(_)
 impl<Err: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::VecDecoderError<Err>
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::clone(&self) -> bitcoin_consensus_encoding::error::VecDecoderError<Err>
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::clone(&self) -> bitcoin_consensus_encoding::error::VecDecoderError<Err> [impl: impl<Err: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::VecDecoderError<Err>]
 impl<Err: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::VecDecoderError<Err>
 impl<Err: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::VecDecoderError<Err>
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::eq(&self, other: &bitcoin_consensus_encoding::error::VecDecoderError<Err>) -> bool
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::eq(&self, other: &bitcoin_consensus_encoding::error::VecDecoderError<Err>) -> bool [impl: impl<Err: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::VecDecoderError<Err>]
+impl<Err: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::VecDecoderError<Err>
 impl<Err: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::VecDecoderError<Err>
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<Err: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::VecDecoderError<Err>]
 impl<Err> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::VecDecoderError<Err>
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::from(never: core::convert::Infallible) -> Self
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::from(never: core::convert::Infallible) -> Self [impl: impl<Err> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::VecDecoderError<Err>]
 impl<Err> core::error::Error for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::error::Error + 'static
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<Err> core::error::Error for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::error::Error + 'static]
 impl<Err> core::fmt::Display for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::fmt::Display + core::fmt::Debug
-impl<Err> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::VecDecoderError<Err>
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<Err> core::fmt::Display for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::fmt::Display + core::fmt::Debug]
 impl<Err> core::marker::Freeze for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::marker::Freeze
 impl<Err> core::marker::Send for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::marker::Send
 impl<Err> core::marker::Sync for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::marker::Sync
@@ -563,29 +576,29 @@ impl<Err> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::VecDe
 impl<Err> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::panic::unwind_safe::RefUnwindSafe
 impl<Err> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::VecDecoderError<Err> where Err: core::panic::unwind_safe::UnwindSafe
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::error::VecDecoderError<Err>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::error::VecDecoderError<Err>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::error::VecDecoderError<Err>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::error::VecDecoderError<Err>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::error::VecDecoderError<Err>::Owned = T
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::error::VecDecoderError<Err>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: core::clone::Clone]
 impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: core::fmt::Display + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::to_string(&self) -> alloc::string::String
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: core::fmt::Display + ?core::marker::Sized]
 impl<T> core::any::Any for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::VecDecoderError<Err> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::VecDecoderError<Err>
-pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::error::VecDecoderError<Err>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::VecDecoderError<Err>]
 pub mod bitcoin_consensus_encoding::serde_as_consensus
 pub mod bitcoin_consensus_encoding::serde_as_consensus::opt
 pub fn bitcoin_consensus_encoding::serde_as_consensus::opt::deserialize<'d, T, D>(d: D) -> core::result::Result<core::option::Option<T>, <D as serde::de::Deserializer>::Error> where T: bitcoin_consensus_encoding::Encode + bitcoin_consensus_encoding::Decode, D: serde::de::Deserializer<'d>
@@ -600,18 +613,192 @@ pub macro bitcoin_consensus_encoding::encoder_newtype_exact!
 pub enum bitcoin_consensus_encoding::DecodeError<Err>
 pub bitcoin_consensus_encoding::DecodeError::Parse(Err)
 pub bitcoin_consensus_encoding::DecodeError::Unconsumed(bitcoin_consensus_encoding::error::UnconsumedError)
+impl<Err: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::DecodeError<Err>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone(&self) -> bitcoin_consensus_encoding::error::DecodeError<Err> [impl: impl<Err: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::DecodeError<Err>]
+impl<Err: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::DecodeError<Err>
+impl<Err: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::DecodeError<Err>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::eq(&self, other: &bitcoin_consensus_encoding::error::DecodeError<Err>) -> bool [impl: impl<Err: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::DecodeError<Err>]
+impl<Err: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::DecodeError<Err>
+impl<Err: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::DecodeError<Err>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<Err: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::DecodeError<Err>]
+impl<Err> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::DecodeError<Err>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::from(never: core::convert::Infallible) -> Self [impl: impl<Err> core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::DecodeError<Err>]
+impl<Err> core::error::Error for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::error::Error + 'static
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<Err> core::error::Error for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::error::Error + 'static]
+impl<Err> core::fmt::Display for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::fmt::Display
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<Err> core::fmt::Display for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::fmt::Display]
+impl<Err> core::marker::Freeze for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::marker::Freeze
+impl<Err> core::marker::Send for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::marker::Send
+impl<Err> core::marker::Sync for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::marker::Sync
+impl<Err> core::marker::Unpin for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::marker::Unpin
+impl<Err> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::marker::UnsafeUnpin
+impl<Err> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::panic::unwind_safe::RefUnwindSafe
+impl<Err> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::DecodeError<Err> where Err: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::From<T>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::From<T>]
+impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::Into<T>
+  pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::Into<T>]
+impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::TryFrom<T>
+  pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::DecodeError<Err> where U: core::convert::TryFrom<T>]
+impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone
+  pub type bitcoin_consensus_encoding::error::DecodeError<Err>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone]
+impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::fmt::Display + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::fmt::Display + ?core::marker::Sized]
+impl<T> core::any::Any for bitcoin_consensus_encoding::error::DecodeError<Err> where T: 'static + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::DecodeError<Err> where T: 'static + ?core::marker::Sized]
+impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::DecodeError<Err> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::DecodeError<Err> where T: ?core::marker::Sized]
+impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::DecodeError<Err> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::DecodeError<Err> where T: ?core::marker::Sized]
+impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone
+  pub unsafe fn bitcoin_consensus_encoding::error::DecodeError<Err>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::DecodeError<Err> where T: core::clone::Clone]
+impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::DecodeError<Err>
+  pub fn bitcoin_consensus_encoding::error::DecodeError<Err>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::DecodeError<Err>]
 pub enum bitcoin_consensus_encoding::Decoder2Error<A, B>
 pub bitcoin_consensus_encoding::Decoder2Error::First(A)
 pub bitcoin_consensus_encoding::Decoder2Error::Second(B)
+impl<A, B> core::error::Error for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::error::Error + 'static, B: core::error::Error + 'static
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<A, B> core::error::Error for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::error::Error + 'static, B: core::error::Error + 'static]
+impl<A, B> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::fmt::Display, B: core::fmt::Display
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A, B> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::fmt::Display, B: core::fmt::Display]
+impl<A: core::clone::Clone, B: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder2Error<A, B> [impl: impl<A: core::clone::Clone, B: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder2Error<A, B>]
+impl<A: core::cmp::Eq, B: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder2Error<A, B>) -> bool [impl: impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>]
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+impl<A: core::fmt::Debug, B: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A: core::fmt::Debug, B: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder2Error<A, B>]
+impl<A, B> core::marker::Freeze for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::marker::Freeze, B: core::marker::Freeze
+impl<A, B> core::marker::Send for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::marker::Send, B: core::marker::Send
+impl<A, B> core::marker::Sync for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::marker::Sync, B: core::marker::Sync
+impl<A, B> core::marker::Unpin for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::marker::Unpin, B: core::marker::Unpin
+impl<A, B> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::marker::UnsafeUnpin, B: core::marker::UnsafeUnpin
+impl<A, B> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::From<T>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::From<T>]
+impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::Into<T>
+  pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::Into<T>]
+impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::TryFrom<T>
+  pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where U: core::convert::TryFrom<T>]
+impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone
+  pub type bitcoin_consensus_encoding::error::Decoder2Error<A, B>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone]
+impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::fmt::Display + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::fmt::Display + ?core::marker::Sized]
+impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: 'static + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: 'static + ?core::marker::Sized]
+impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: ?core::marker::Sized]
+impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: ?core::marker::Sized]
+impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone
+  pub unsafe fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder2Error<A, B> where T: core::clone::Clone]
+impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B>
+  pub fn bitcoin_consensus_encoding::error::Decoder2Error<A, B>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder2Error<A, B>]
 pub enum bitcoin_consensus_encoding::Decoder3Error<A, B, C>
 pub bitcoin_consensus_encoding::Decoder3Error::First(A)
 pub bitcoin_consensus_encoding::Decoder3Error::Second(B)
 pub bitcoin_consensus_encoding::Decoder3Error::Third(C)
+impl<A, B, C> core::error::Error for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<A, B, C> core::error::Error for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static]
+impl<A, B, C> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A, B, C> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display]
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> [impl: impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>]
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>) -> bool [impl: impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>]
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>]
+impl<A, B, C> core::marker::Freeze for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze
+impl<A, B, C> core::marker::Send for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send
+impl<A, B, C> core::marker::Sync for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync
+impl<A, B, C> core::marker::Unpin for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin
+impl<A, B, C> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::marker::UnsafeUnpin, B: core::marker::UnsafeUnpin, C: core::marker::UnsafeUnpin
+impl<A, B, C> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::From<T>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::From<T>]
+impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::Into<T>
+  pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::Into<T>]
+impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::TryFrom<T>
+  pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where U: core::convert::TryFrom<T>]
+impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone
+  pub type bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone]
+impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::fmt::Display + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::fmt::Display + ?core::marker::Sized]
+impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: 'static + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: 'static + ?core::marker::Sized]
+impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: ?core::marker::Sized]
+impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: ?core::marker::Sized]
+impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone
+  pub unsafe fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C> where T: core::clone::Clone]
+impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>
+  pub fn bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder3Error<A, B, C>]
 pub enum bitcoin_consensus_encoding::Decoder4Error<A, B, C, D>
 pub bitcoin_consensus_encoding::Decoder4Error::First(A)
 pub bitcoin_consensus_encoding::Decoder4Error::Fourth(D)
 pub bitcoin_consensus_encoding::Decoder4Error::Second(B)
 pub bitcoin_consensus_encoding::Decoder4Error::Third(C)
+impl<A, B, C, D> core::error::Error for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<A, B, C, D> core::error::Error for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static]
+impl<A, B, C, D> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A, B, C, D> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display]
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> [impl: impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>]
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>) -> bool [impl: impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>]
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>]
+impl<A, B, C, D> core::marker::Freeze for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze
+impl<A, B, C, D> core::marker::Send for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send
+impl<A, B, C, D> core::marker::Sync for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync
+impl<A, B, C, D> core::marker::Unpin for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin
+impl<A, B, C, D> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::marker::UnsafeUnpin, B: core::marker::UnsafeUnpin, C: core::marker::UnsafeUnpin, D: core::marker::UnsafeUnpin
+impl<A, B, C, D> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::From<T>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::From<T>]
+impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::Into<T>
+  pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::Into<T>]
+impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::TryFrom<T>
+  pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where U: core::convert::TryFrom<T>]
+impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone
+  pub type bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone]
+impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::fmt::Display + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::fmt::Display + ?core::marker::Sized]
+impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: 'static + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: 'static + ?core::marker::Sized]
+impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: ?core::marker::Sized]
+impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: ?core::marker::Sized]
+impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone
+  pub unsafe fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D> where T: core::clone::Clone]
+impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>
+  pub fn bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder4Error<A, B, C, D>]
 pub enum bitcoin_consensus_encoding::Decoder6Error<A, B, C, D, E, F>
 pub bitcoin_consensus_encoding::Decoder6Error::Fifth(E)
 pub bitcoin_consensus_encoding::Decoder6Error::First(A)
@@ -619,6 +806,49 @@ pub bitcoin_consensus_encoding::Decoder6Error::Fourth(D)
 pub bitcoin_consensus_encoding::Decoder6Error::Second(B)
 pub bitcoin_consensus_encoding::Decoder6Error::Sixth(F)
 pub bitcoin_consensus_encoding::Decoder6Error::Third(C)
+impl<A, B, C, D, E, F> core::error::Error for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static, E: core::error::Error + 'static, F: core::error::Error + 'static
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<A, B, C, D, E, F> core::error::Error for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::error::Error + 'static, B: core::error::Error + 'static, C: core::error::Error + 'static, D: core::error::Error + 'static, E: core::error::Error + 'static, F: core::error::Error + 'static]
+impl<A, B, C, D, E, F> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display, E: core::fmt::Display, F: core::fmt::Display
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A, B, C, D, E, F> core::fmt::Display for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::fmt::Display, B: core::fmt::Display, C: core::fmt::Display, D: core::fmt::Display, E: core::fmt::Display, F: core::fmt::Display]
+impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone, E: core::clone::Clone, F: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone(&self) -> bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> [impl: impl<A: core::clone::Clone, B: core::clone::Clone, C: core::clone::Clone, D: core::clone::Clone, E: core::clone::Clone, F: core::clone::Clone> core::clone::Clone for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>]
+impl<A: core::cmp::Eq, B: core::cmp::Eq, C: core::cmp::Eq, D: core::cmp::Eq, E: core::cmp::Eq, F: core::cmp::Eq> core::cmp::Eq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::eq(&self, other: &bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>) -> bool [impl: impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>]
+impl<A: core::cmp::PartialEq, B: core::cmp::PartialEq, C: core::cmp::PartialEq, D: core::cmp::PartialEq, E: core::cmp::PartialEq, F: core::cmp::PartialEq> core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug, E: core::fmt::Debug, F: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<A: core::fmt::Debug, B: core::fmt::Debug, C: core::fmt::Debug, D: core::fmt::Debug, E: core::fmt::Debug, F: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>]
+impl<A, B, C, D, E, F> core::marker::Freeze for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Freeze, B: core::marker::Freeze, C: core::marker::Freeze, D: core::marker::Freeze, E: core::marker::Freeze, F: core::marker::Freeze
+impl<A, B, C, D, E, F> core::marker::Send for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Send, B: core::marker::Send, C: core::marker::Send, D: core::marker::Send, E: core::marker::Send, F: core::marker::Send
+impl<A, B, C, D, E, F> core::marker::Sync for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Sync, B: core::marker::Sync, C: core::marker::Sync, D: core::marker::Sync, E: core::marker::Sync, F: core::marker::Sync
+impl<A, B, C, D, E, F> core::marker::Unpin for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::marker::Unpin, B: core::marker::Unpin, C: core::marker::Unpin, D: core::marker::Unpin, E: core::marker::Unpin, F: core::marker::Unpin
+impl<A, B, C, D, E, F> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::marker::UnsafeUnpin, B: core::marker::UnsafeUnpin, C: core::marker::UnsafeUnpin, D: core::marker::UnsafeUnpin, E: core::marker::UnsafeUnpin, F: core::marker::UnsafeUnpin
+impl<A, B, C, D, E, F> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::RefUnwindSafe, B: core::panic::unwind_safe::RefUnwindSafe, C: core::panic::unwind_safe::RefUnwindSafe, D: core::panic::unwind_safe::RefUnwindSafe, E: core::panic::unwind_safe::RefUnwindSafe, F: core::panic::unwind_safe::RefUnwindSafe
+impl<A, B, C, D, E, F> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where A: core::panic::unwind_safe::UnwindSafe, B: core::panic::unwind_safe::UnwindSafe, C: core::panic::unwind_safe::UnwindSafe, D: core::panic::unwind_safe::UnwindSafe, E: core::panic::unwind_safe::UnwindSafe, F: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::From<T>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::From<T>]
+impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::Into<T>
+  pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::Into<T>]
+impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::TryFrom<T>
+  pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where U: core::convert::TryFrom<T>]
+impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone
+  pub type bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone]
+impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::fmt::Display + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::fmt::Display + ?core::marker::Sized]
+impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: 'static + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: 'static + ?core::marker::Sized]
+impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: ?core::marker::Sized]
+impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: ?core::marker::Sized]
+impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone
+  pub unsafe fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F> where T: core::clone::Clone]
+impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>
+  pub fn bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::Decoder6Error<A, B, C, D, E, F>]
 pub enum bitcoin_consensus_encoding::DecoderStatus
 pub bitcoin_consensus_encoding::DecoderStatus::NeedsMore
 pub bitcoin_consensus_encoding::DecoderStatus::Ready
@@ -626,12 +856,12 @@ impl bitcoin_consensus_encoding::DecoderStatus
 pub fn bitcoin_consensus_encoding::DecoderStatus::is_ready(&self) -> bool
 pub fn bitcoin_consensus_encoding::DecoderStatus::needs_more(&self) -> bool
 impl core::clone::Clone for bitcoin_consensus_encoding::DecoderStatus
-pub fn bitcoin_consensus_encoding::DecoderStatus::clone(&self) -> bitcoin_consensus_encoding::DecoderStatus
+  pub fn bitcoin_consensus_encoding::DecoderStatus::clone(&self) -> bitcoin_consensus_encoding::DecoderStatus [impl: impl core::clone::Clone for bitcoin_consensus_encoding::DecoderStatus]
 impl core::cmp::Eq for bitcoin_consensus_encoding::DecoderStatus
 impl core::cmp::PartialEq for bitcoin_consensus_encoding::DecoderStatus
-pub fn bitcoin_consensus_encoding::DecoderStatus::eq(&self, other: &bitcoin_consensus_encoding::DecoderStatus) -> bool
+  pub fn bitcoin_consensus_encoding::DecoderStatus::eq(&self, other: &bitcoin_consensus_encoding::DecoderStatus) -> bool [impl: impl core::cmp::PartialEq for bitcoin_consensus_encoding::DecoderStatus]
 impl core::fmt::Debug for bitcoin_consensus_encoding::DecoderStatus
-pub fn bitcoin_consensus_encoding::DecoderStatus::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::DecoderStatus::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::DecoderStatus]
 impl core::marker::Copy for bitcoin_consensus_encoding::DecoderStatus
 impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::DecoderStatus
 impl core::marker::Freeze for bitcoin_consensus_encoding::DecoderStatus
@@ -642,27 +872,27 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::DecoderStatus
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::DecoderStatus
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::DecoderStatus
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::DecoderStatus where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::DecoderStatus::into(self) -> U
+  pub fn bitcoin_consensus_encoding::DecoderStatus::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::DecoderStatus where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::DecoderStatus where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::DecoderStatus::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::DecoderStatus::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::DecoderStatus::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::DecoderStatus where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::DecoderStatus::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::DecoderStatus where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::DecoderStatus where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::DecoderStatus::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::DecoderStatus::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::DecoderStatus::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::DecoderStatus where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::DecoderStatus::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::DecoderStatus where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::DecoderStatus where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::DecoderStatus::Owned = T
-pub fn bitcoin_consensus_encoding::DecoderStatus::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::DecoderStatus::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::DecoderStatus::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::DecoderStatus where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::DecoderStatus::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::DecoderStatus where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::DecoderStatus::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::DecoderStatus where T: core::clone::Clone]
 impl<T> core::any::Any for bitcoin_consensus_encoding::DecoderStatus where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::DecoderStatus::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::DecoderStatus::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::DecoderStatus where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::DecoderStatus where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::DecoderStatus::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::DecoderStatus::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::DecoderStatus where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::DecoderStatus where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::DecoderStatus::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::DecoderStatus::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::DecoderStatus where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::DecoderStatus where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::DecoderStatus::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::DecoderStatus::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::DecoderStatus where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::DecoderStatus
-pub fn bitcoin_consensus_encoding::DecoderStatus::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::DecoderStatus::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::DecoderStatus]
 pub enum bitcoin_consensus_encoding::EncoderStatus
 pub bitcoin_consensus_encoding::EncoderStatus::Finished
 pub bitcoin_consensus_encoding::EncoderStatus::HasMore
@@ -670,12 +900,12 @@ impl bitcoin_consensus_encoding::EncoderStatus
 pub fn bitcoin_consensus_encoding::EncoderStatus::has_finished(&self) -> bool
 pub fn bitcoin_consensus_encoding::EncoderStatus::has_more(&self) -> bool
 impl core::clone::Clone for bitcoin_consensus_encoding::EncoderStatus
-pub fn bitcoin_consensus_encoding::EncoderStatus::clone(&self) -> bitcoin_consensus_encoding::EncoderStatus
+  pub fn bitcoin_consensus_encoding::EncoderStatus::clone(&self) -> bitcoin_consensus_encoding::EncoderStatus [impl: impl core::clone::Clone for bitcoin_consensus_encoding::EncoderStatus]
 impl core::cmp::Eq for bitcoin_consensus_encoding::EncoderStatus
 impl core::cmp::PartialEq for bitcoin_consensus_encoding::EncoderStatus
-pub fn bitcoin_consensus_encoding::EncoderStatus::eq(&self, other: &bitcoin_consensus_encoding::EncoderStatus) -> bool
+  pub fn bitcoin_consensus_encoding::EncoderStatus::eq(&self, other: &bitcoin_consensus_encoding::EncoderStatus) -> bool [impl: impl core::cmp::PartialEq for bitcoin_consensus_encoding::EncoderStatus]
 impl core::fmt::Debug for bitcoin_consensus_encoding::EncoderStatus
-pub fn bitcoin_consensus_encoding::EncoderStatus::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::EncoderStatus::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::EncoderStatus]
 impl core::marker::Copy for bitcoin_consensus_encoding::EncoderStatus
 impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::EncoderStatus
 impl core::marker::Freeze for bitcoin_consensus_encoding::EncoderStatus
@@ -686,45 +916,78 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::EncoderStatus
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::EncoderStatus
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::EncoderStatus
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::EncoderStatus where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::EncoderStatus::into(self) -> U
+  pub fn bitcoin_consensus_encoding::EncoderStatus::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::EncoderStatus where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::EncoderStatus where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::EncoderStatus::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::EncoderStatus::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::EncoderStatus::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::EncoderStatus where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::EncoderStatus::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::EncoderStatus where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::EncoderStatus where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::EncoderStatus::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::EncoderStatus::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::EncoderStatus::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::EncoderStatus where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::EncoderStatus::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::EncoderStatus where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::EncoderStatus where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::EncoderStatus::Owned = T
-pub fn bitcoin_consensus_encoding::EncoderStatus::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::EncoderStatus::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::EncoderStatus::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::EncoderStatus where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::EncoderStatus::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::EncoderStatus where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::EncoderStatus::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::EncoderStatus where T: core::clone::Clone]
 impl<T> core::any::Any for bitcoin_consensus_encoding::EncoderStatus where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::EncoderStatus::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::EncoderStatus::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::EncoderStatus where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::EncoderStatus where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::EncoderStatus::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::EncoderStatus::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::EncoderStatus where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::EncoderStatus where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::EncoderStatus::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::EncoderStatus::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::EncoderStatus where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::EncoderStatus where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::EncoderStatus::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::EncoderStatus::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::EncoderStatus where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::EncoderStatus
-pub fn bitcoin_consensus_encoding::EncoderStatus::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::EncoderStatus::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::EncoderStatus]
 pub enum bitcoin_consensus_encoding::ReadError<D>
 pub bitcoin_consensus_encoding::ReadError::Decode(D)
 pub bitcoin_consensus_encoding::ReadError::Io(std::io::error::Error)
+impl<D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::ReadError<D>
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<D: core::fmt::Debug> core::fmt::Debug for bitcoin_consensus_encoding::error::ReadError<D>]
+impl<D: core::fmt::Display> core::fmt::Display for bitcoin_consensus_encoding::error::ReadError<D>
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<D: core::fmt::Display> core::fmt::Display for bitcoin_consensus_encoding::error::ReadError<D>]
+impl<D> core::convert::From<std::io::error::Error> for bitcoin_consensus_encoding::error::ReadError<D>
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::from(e: std::io::error::Error) -> Self [impl: impl<D> core::convert::From<std::io::error::Error> for bitcoin_consensus_encoding::error::ReadError<D>]
+impl<D> core::error::Error for bitcoin_consensus_encoding::error::ReadError<D> where D: core::error::Error + 'static
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl<D> core::error::Error for bitcoin_consensus_encoding::error::ReadError<D> where D: core::error::Error + 'static]
+impl<D> core::marker::Freeze for bitcoin_consensus_encoding::error::ReadError<D> where D: core::marker::Freeze
+impl<D> core::marker::Send for bitcoin_consensus_encoding::error::ReadError<D> where D: core::marker::Send
+impl<D> core::marker::Sync for bitcoin_consensus_encoding::error::ReadError<D> where D: core::marker::Sync
+impl<D> core::marker::Unpin for bitcoin_consensus_encoding::error::ReadError<D> where D: core::marker::Unpin
+impl<D> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::ReadError<D> where D: core::marker::UnsafeUnpin
+impl<D> !core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::ReadError<D>
+impl<D> !core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::ReadError<D>
+impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::From<T>
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::From<T>]
+impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::Into<T>
+  pub type bitcoin_consensus_encoding::error::ReadError<D>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::Into<T>]
+impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::TryFrom<T>
+  pub type bitcoin_consensus_encoding::error::ReadError<D>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ReadError<D> where U: core::convert::TryFrom<T>]
+impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::ReadError<D> where T: core::fmt::Display + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::ReadError<D> where T: core::fmt::Display + ?core::marker::Sized]
+impl<T> core::any::Any for bitcoin_consensus_encoding::error::ReadError<D> where T: 'static + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::ReadError<D> where T: 'static + ?core::marker::Sized]
+impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::ReadError<D> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::ReadError<D> where T: ?core::marker::Sized]
+impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::ReadError<D> where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::ReadError<D> where T: ?core::marker::Sized]
+impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::ReadError<D>
+  pub fn bitcoin_consensus_encoding::error::ReadError<D>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::ReadError<D>]
 pub struct bitcoin_consensus_encoding::ArrayDecoder<const N: usize>
 impl<const N: usize> bitcoin_consensus_encoding::ArrayDecoder<N>
 pub const fn bitcoin_consensus_encoding::ArrayDecoder<N>::new() -> Self
 impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>
-pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = bitcoin_consensus_encoding::error::UnexpectedEofError
-pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Output = [u8; N]
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::end(self) -> core::result::Result<Self::Output, Self::Error>
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error>
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::read_limit(&self) -> usize
+  pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = bitcoin_consensus_encoding::error::UnexpectedEofError [impl: impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>]
+  pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Output = [u8; N] [impl: impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>]
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::end(self) -> core::result::Result<Self::Output, Self::Error> [impl: impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>]
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> [impl: impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>]
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::read_limit(&self) -> usize [impl: impl<const N: usize> bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ArrayDecoder<N>]
 impl<const N: usize> core::clone::Clone for bitcoin_consensus_encoding::ArrayDecoder<N>
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::clone(&self) -> bitcoin_consensus_encoding::ArrayDecoder<N>
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::clone(&self) -> bitcoin_consensus_encoding::ArrayDecoder<N> [impl: impl<const N: usize> core::clone::Clone for bitcoin_consensus_encoding::ArrayDecoder<N>]
 impl<const N: usize> core::default::Default for bitcoin_consensus_encoding::ArrayDecoder<N>
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::default() -> Self
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::default() -> Self [impl: impl<const N: usize> core::default::Default for bitcoin_consensus_encoding::ArrayDecoder<N>]
 impl<const N: usize> core::fmt::Debug for bitcoin_consensus_encoding::ArrayDecoder<N>
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<const N: usize> core::fmt::Debug for bitcoin_consensus_encoding::ArrayDecoder<N>]
 impl<const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayDecoder<N>
 impl<const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayDecoder<N>
 impl<const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayDecoder<N>
@@ -733,39 +996,39 @@ impl<const N: usize> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::A
 impl<const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayDecoder<N>
 impl<const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayDecoder<N>
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::ArrayDecoder<N> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::ArrayDecoder<N> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayDecoder<N> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayDecoder<N> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayDecoder<N> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayDecoder<N> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayDecoder<N> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayDecoder<N> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayDecoder<N> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Owned = T
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::ArrayDecoder<N>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayDecoder<N> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayDecoder<N> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayDecoder<N> where T: core::clone::Clone]
 impl<T> core::any::Any for bitcoin_consensus_encoding::ArrayDecoder<N> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::ArrayDecoder<N> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::ArrayDecoder<N> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::ArrayDecoder<N> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::ArrayDecoder<N> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::ArrayDecoder<N> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::ArrayDecoder<N> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::ArrayDecoder<N>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::ArrayDecoder<N>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::ArrayDecoder<N> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::ArrayDecoder<N>
-pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::ArrayDecoder<N>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::ArrayDecoder<N>]
 pub struct bitcoin_consensus_encoding::ArrayEncoder<const N: usize>
 impl<const N: usize> bitcoin_consensus_encoding::ArrayEncoder<N>
 pub const fn bitcoin_consensus_encoding::ArrayEncoder<N>::without_length_prefix(arr: [u8; N]) -> Self
 impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayEncoder<N>
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::advance(&mut self) -> bitcoin_consensus_encoding::EncoderStatus
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::current_chunk(&self) -> &[u8]
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::advance(&mut self) -> bitcoin_consensus_encoding::EncoderStatus [impl: impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayEncoder<N>]
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::current_chunk(&self) -> &[u8] [impl: impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayEncoder<N>]
 impl<const N: usize> bitcoin_consensus_encoding::ExactSizeEncoder for bitcoin_consensus_encoding::ArrayEncoder<N>
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::len(&self) -> usize
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::len(&self) -> usize [impl: impl<const N: usize> bitcoin_consensus_encoding::ExactSizeEncoder for bitcoin_consensus_encoding::ArrayEncoder<N>]
 impl<const N: usize> core::clone::Clone for bitcoin_consensus_encoding::ArrayEncoder<N>
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::clone(&self) -> bitcoin_consensus_encoding::ArrayEncoder<N>
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::clone(&self) -> bitcoin_consensus_encoding::ArrayEncoder<N> [impl: impl<const N: usize> core::clone::Clone for bitcoin_consensus_encoding::ArrayEncoder<N>]
 impl<const N: usize> core::fmt::Debug for bitcoin_consensus_encoding::ArrayEncoder<N>
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<const N: usize> core::fmt::Debug for bitcoin_consensus_encoding::ArrayEncoder<N>]
 impl<const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayEncoder<N>
 impl<const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayEncoder<N>
 impl<const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayEncoder<N>
@@ -774,39 +1037,39 @@ impl<const N: usize> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::A
 impl<const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayEncoder<N>
 impl<const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayEncoder<N>
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::ArrayEncoder<N> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::ArrayEncoder<N> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayEncoder<N> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::ArrayEncoder<N>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::ArrayEncoder<N>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayEncoder<N> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayEncoder<N> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayEncoder<N> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::ArrayEncoder<N>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::ArrayEncoder<N>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayEncoder<N> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayEncoder<N> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayEncoder<N> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::ArrayEncoder<N>::Owned = T
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::ArrayEncoder<N>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayEncoder<N> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayEncoder<N> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayEncoder<N> where T: core::clone::Clone]
 impl<T> core::any::Any for bitcoin_consensus_encoding::ArrayEncoder<N> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::ArrayEncoder<N> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::ArrayEncoder<N> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::ArrayEncoder<N> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::ArrayEncoder<N> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::ArrayEncoder<N> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::ArrayEncoder<N> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::ArrayEncoder<N>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::ArrayEncoder<N>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::ArrayEncoder<N> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::ArrayEncoder<N>
-pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::ArrayEncoder<N>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::ArrayEncoder<N>]
 pub struct bitcoin_consensus_encoding::ArrayRefEncoder<'e, const N: usize>
 impl<'e, const N: usize> bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
 pub const fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::without_length_prefix(arr: &'e [u8; N]) -> Self
 impl<'e, const N: usize> core::clone::Clone for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::clone(&self) -> bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::clone(&self) -> bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> [impl: impl<'e, const N: usize> core::clone::Clone for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>]
 impl<'e, const N: usize> core::fmt::Debug for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<'e, const N: usize> core::fmt::Debug for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>]
 impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>::advance(&mut self) -> bitcoin_consensus_encoding::EncoderStatus
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>::current_chunk(&self) -> &[u8]
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>::advance(&mut self) -> bitcoin_consensus_encoding::EncoderStatus [impl: impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>]
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>::current_chunk(&self) -> &[u8] [impl: impl<const N: usize> bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>]
 impl<const N: usize> bitcoin_consensus_encoding::ExactSizeEncoder for bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>::len(&self) -> usize
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>::len(&self) -> usize [impl: impl<const N: usize> bitcoin_consensus_encoding::ExactSizeEncoder for bitcoin_consensus_encoding::ArrayRefEncoder<'_, N>]
 impl<'e, const N: usize> core::marker::Freeze for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
 impl<'e, const N: usize> core::marker::Send for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
 impl<'e, const N: usize> core::marker::Sync for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
@@ -815,43 +1078,43 @@ impl<'e, const N: usize> core::marker::UnsafeUnpin for bitcoin_consensus_encodin
 impl<'e, const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
 impl<'e, const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::Owned = T
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: core::clone::Clone]
 impl<T> core::any::Any for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>
-pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::ArrayRefEncoder<'e, N>]
 pub struct bitcoin_consensus_encoding::ByteVecDecoder
 impl bitcoin_consensus_encoding::ByteVecDecoder
 pub const fn bitcoin_consensus_encoding::ByteVecDecoder::new() -> Self
 pub const fn bitcoin_consensus_encoding::ByteVecDecoder::new_with_limit(limit: usize) -> Self
 impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ByteVecDecoder
-pub type bitcoin_consensus_encoding::ByteVecDecoder::Error = bitcoin_consensus_encoding::error::ByteVecDecoderError
-pub type bitcoin_consensus_encoding::ByteVecDecoder::Output = alloc::vec::Vec<u8>
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error>
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::read_limit(&self) -> usize
+  pub type bitcoin_consensus_encoding::ByteVecDecoder::Error = bitcoin_consensus_encoding::error::ByteVecDecoderError [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ByteVecDecoder]
+  pub type bitcoin_consensus_encoding::ByteVecDecoder::Output = alloc::vec::Vec<u8> [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ByteVecDecoder]
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::end(self) -> core::result::Result<Self::Output, Self::Error> [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ByteVecDecoder]
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ByteVecDecoder]
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::read_limit(&self) -> usize [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::ByteVecDecoder]
 impl core::clone::Clone for bitcoin_consensus_encoding::ByteVecDecoder
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::clone(&self) -> bitcoin_consensus_encoding::ByteVecDecoder
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::clone(&self) -> bitcoin_consensus_encoding::ByteVecDecoder [impl: impl core::clone::Clone for bitcoin_consensus_encoding::ByteVecDecoder]
 impl core::default::Default for bitcoin_consensus_encoding::ByteVecDecoder
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::default() -> Self
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::default() -> Self [impl: impl core::default::Default for bitcoin_consensus_encoding::ByteVecDecoder]
 impl core::fmt::Debug for bitcoin_consensus_encoding::ByteVecDecoder
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::ByteVecDecoder]
 impl core::marker::Freeze for bitcoin_consensus_encoding::ByteVecDecoder
 impl core::marker::Send for bitcoin_consensus_encoding::ByteVecDecoder
 impl core::marker::Sync for bitcoin_consensus_encoding::ByteVecDecoder
@@ -860,40 +1123,85 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::ByteVecDecoder
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::ByteVecDecoder
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::ByteVecDecoder
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::ByteVecDecoder where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::into(self) -> U
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::ByteVecDecoder where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ByteVecDecoder where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::ByteVecDecoder::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::ByteVecDecoder::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ByteVecDecoder where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::ByteVecDecoder where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ByteVecDecoder where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::ByteVecDecoder::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::ByteVecDecoder::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ByteVecDecoder where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::ByteVecDecoder where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ByteVecDecoder where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::ByteVecDecoder::Owned = T
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::ByteVecDecoder::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ByteVecDecoder where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ByteVecDecoder where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::ByteVecDecoder where T: core::clone::Clone]
 impl<T> core::any::Any for bitcoin_consensus_encoding::ByteVecDecoder where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::ByteVecDecoder where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::ByteVecDecoder where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::ByteVecDecoder where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::ByteVecDecoder where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::ByteVecDecoder where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::ByteVecDecoder where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::ByteVecDecoder::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::ByteVecDecoder::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::ByteVecDecoder where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::ByteVecDecoder
-pub fn bitcoin_consensus_encoding::ByteVecDecoder::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::ByteVecDecoder::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::ByteVecDecoder]
 pub struct bitcoin_consensus_encoding::ByteVecDecoderError(_)
+impl core::clone::Clone for bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone(&self) -> bitcoin_consensus_encoding::error::ByteVecDecoderError [impl: impl core::clone::Clone for bitcoin_consensus_encoding::error::ByteVecDecoderError]
+impl core::cmp::Eq for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::eq(&self, other: &bitcoin_consensus_encoding::error::ByteVecDecoderError) -> bool [impl: impl core::cmp::PartialEq for bitcoin_consensus_encoding::error::ByteVecDecoderError]
+impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::from(never: core::convert::Infallible) -> Self [impl: impl core::convert::From<core::convert::Infallible> for bitcoin_consensus_encoding::error::ByteVecDecoderError]
+impl core::error::Error for bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> [impl: impl core::error::Error for bitcoin_consensus_encoding::error::ByteVecDecoderError]
+impl core::fmt::Debug for bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::error::ByteVecDecoderError]
+impl core::fmt::Display for bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Display for bitcoin_consensus_encoding::error::ByteVecDecoderError]
+impl core::marker::StructuralPartialEq for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl core::marker::Freeze for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl core::marker::Send for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl core::marker::Sync for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl core::marker::Unpin for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::error::ByteVecDecoderError
+impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::From<T>
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::From<T>]
+impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::Into<T>
+  pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::Into<T>]
+impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::TryFrom<T>
+  pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::error::ByteVecDecoderError where U: core::convert::TryFrom<T>]
+impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone
+  pub type bitcoin_consensus_encoding::error::ByteVecDecoderError::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone]
+impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::fmt::Display + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::to_string(&self) -> alloc::string::String [impl: impl<T> alloc::string::ToString for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::fmt::Display + ?core::marker::Sized]
+impl<T> core::any::Any for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: 'static + ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: 'static + ?core::marker::Sized]
+impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: ?core::marker::Sized]
+impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: ?core::marker::Sized
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: ?core::marker::Sized]
+impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone
+  pub unsafe fn bitcoin_consensus_encoding::error::ByteVecDecoderError::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::error::ByteVecDecoderError where T: core::clone::Clone]
+impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError
+  pub fn bitcoin_consensus_encoding::error::ByteVecDecoderError::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::error::ByteVecDecoderError]
 pub struct bitcoin_consensus_encoding::BytesEncoder<'sl>
 impl<'sl> bitcoin_consensus_encoding::BytesEncoder<'sl>
 pub const fn bitcoin_consensus_encoding::BytesEncoder<'sl>::without_length_prefix(sl: &'sl [u8]) -> Self
 impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::BytesEncoder<'_>
-pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::advance(&mut self) -> bitcoin_consensus_encoding::EncoderStatus
-pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::current_chunk(&self) -> &[u8]
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::advance(&mut self) -> bitcoin_consensus_encoding::EncoderStatus [impl: impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::BytesEncoder<'_>]
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'_>::current_chunk(&self) -> &[u8] [impl: impl bitcoin_consensus_encoding::Encoder for bitcoin_consensus_encoding::BytesEncoder<'_>]
 impl<'sl> bitcoin_consensus_encoding::ExactSizeEncoder for bitcoin_consensus_encoding::BytesEncoder<'sl>
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::len(&self) -> usize
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::len(&self) -> usize [impl: impl<'sl> bitcoin_consensus_encoding::ExactSizeEncoder for bitcoin_consensus_encoding::BytesEncoder<'sl>]
 impl<'sl> core::clone::Clone for bitcoin_consensus_encoding::BytesEncoder<'sl>
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::clone(&self) -> bitcoin_consensus_encoding::BytesEncoder<'sl>
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::clone(&self) -> bitcoin_consensus_encoding::BytesEncoder<'sl> [impl: impl<'sl> core::clone::Clone for bitcoin_consensus_encoding::BytesEncoder<'sl>]
 impl<'sl> core::fmt::Debug for bitcoin_consensus_encoding::BytesEncoder<'sl>
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl<'sl> core::fmt::Debug for bitcoin_consensus_encoding::BytesEncoder<'sl>]
 impl<'sl> core::marker::Freeze for bitcoin_consensus_encoding::BytesEncoder<'sl>
 impl<'sl> core::marker::Send for bitcoin_consensus_encoding::BytesEncoder<'sl>
 impl<'sl> core::marker::Sync for bitcoin_consensus_encoding::BytesEncoder<'sl>
@@ -902,43 +1210,43 @@ impl<'sl> core::marker::UnsafeUnpin for bitcoin_consensus_encoding::BytesEncoder
 impl<'sl> core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::BytesEncoder<'sl>
 impl<'sl> core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::BytesEncoder<'sl>
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::BytesEncoder<'sl> where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::into(self) -> U
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::BytesEncoder<'sl> where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::BytesEncoder<'sl> where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::BytesEncoder<'sl>::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::BytesEncoder<'sl>::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::BytesEncoder<'sl> where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::BytesEncoder<'sl> where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::BytesEncoder<'sl> where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::BytesEncoder<'sl>::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::BytesEncoder<'sl>::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::BytesEncoder<'sl> where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::BytesEncoder<'sl> where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: core::clone::Clone
-pub type bitcoin_consensus_encoding::BytesEncoder<'sl>::Owned = T
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::clone_into(&self, target: &mut T)
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::to_owned(&self) -> T
+  pub type bitcoin_consensus_encoding::BytesEncoder<'sl>::Owned = T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::clone_into(&self, target: &mut T) [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: core::clone::Clone]
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::to_owned(&self) -> T [impl: impl<T> alloc::borrow::ToOwned for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: core::clone::Clone]
 impl<T> core::any::Any for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: 'static + ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::type_id(&self) -> core::any::TypeId
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::type_id(&self) -> core::any::TypeId [impl: impl<T> core::any::Any for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: 'static + ?core::marker::Sized]
 impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::borrow(&self) -> &T
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::borrow(&self) -> &T [impl: impl<T> core::borrow::Borrow<T> for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: ?core::marker::Sized]
 impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: ?core::marker::Sized
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::borrow_mut(&mut self) -> &mut T
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::borrow_mut(&mut self) -> &mut T [impl: impl<T> core::borrow::BorrowMut<T> for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: ?core::marker::Sized]
 impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: core::clone::Clone
-pub unsafe fn bitcoin_consensus_encoding::BytesEncoder<'sl>::clone_to_uninit(&self, dest: *mut u8)
+  pub unsafe fn bitcoin_consensus_encoding::BytesEncoder<'sl>::clone_to_uninit(&self, dest: *mut u8) [impl: impl<T> core::clone::CloneToUninit for bitcoin_consensus_encoding::BytesEncoder<'sl> where T: core::clone::Clone]
 impl<T> core::convert::From<T> for bitcoin_consensus_encoding::BytesEncoder<'sl>
-pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::from(t: T) -> T
+  pub fn bitcoin_consensus_encoding::BytesEncoder<'sl>::from(t: T) -> T [impl: impl<T> core::convert::From<T> for bitcoin_consensus_encoding::BytesEncoder<'sl>]
 pub struct bitcoin_consensus_encoding::CompactSizeDecoder
 impl bitcoin_consensus_encoding::CompactSizeDecoder
 pub const fn bitcoin_consensus_encoding::CompactSizeDecoder::new() -> Self
 pub const fn bitcoin_consensus_encoding::CompactSizeDecoder::new_with_limit(limit: usize) -> Self
 impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder
-pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = bitcoin_consensus_encoding::error::CompactSizeDecoderError
-pub type bitcoin_consensus_encoding::CompactSizeDecoder::Output = usize
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error>
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error>
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::read_limit(&self) -> usize
+  pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = bitcoin_consensus_encoding::error::CompactSizeDecoderError [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder]
+  pub type bitcoin_consensus_encoding::CompactSizeDecoder::Output = usize [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder]
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::end(self) -> core::result::Result<Self::Output, Self::Error> [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder]
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::push_bytes(&mut self, bytes: &mut &[u8]) -> core::result::Result<bitcoin_consensus_encoding::DecoderStatus, Self::Error> [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder]
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::read_limit(&self) -> usize [impl: impl bitcoin_consensus_encoding::Decoder for bitcoin_consensus_encoding::CompactSizeDecoder]
 impl core::clone::Clone for bitcoin_consensus_encoding::CompactSizeDecoder
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::clone(&self) -> bitcoin_consensus_encoding::CompactSizeDecoder
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::clone(&self) -> bitcoin_consensus_encoding::CompactSizeDecoder [impl: impl core::clone::Clone for bitcoin_consensus_encoding::CompactSizeDecoder]
 impl core::default::Default for bitcoin_consensus_encoding::CompactSizeDecoder
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::default() -> Self
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::default() -> Self [impl: impl core::default::Default for bitcoin_consensus_encoding::CompactSizeDecoder]
 impl core::fmt::Debug for bitcoin_consensus_encoding::CompactSizeDecoder
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result [impl: impl core::fmt::Debug for bitcoin_consensus_encoding::CompactSizeDecoder]
 impl core::marker::Freeze for bitcoin_consensus_encoding::CompactSizeDecoder
 impl core::marker::Send for bitcoin_consensus_encoding::CompactSizeDecoder
 impl core::marker::Sync for bitcoin_consensus_encoding::CompactSizeDecoder
@@ -947,42 +1255,87 @@ impl core::marker::UnsafeUnpin for bitcoin_consensus_encoding::CompactSizeDecode
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoder
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_consensus_encoding::CompactSizeDecoder
 impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::CompactSizeDecoder where U: core::convert::From<T>
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::into(self) -> U
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::into(self) -> U [impl: impl<T, U> core::convert::Into<U> for bitcoin_consensus_encoding::CompactSizeDecoder where U: core::convert::From<T>]
 impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::CompactSizeDecoder where U: core::convert::Into<T>
-pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = core::convert::Infallible
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+  pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = core::convert::Infallible [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::CompactSizeDecoder where U: core::convert::Into<T>]
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error> [impl: impl<T, U> core::convert::TryFrom<U> for bitcoin_consensus_encoding::CompactSizeDecoder where U: core::convert::Into<T>]
 impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::CompactSizeDecoder where U: core::convert::TryFrom<T>
-pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = <U as core::convert::TryFrom<T>>::Error
-pub fn bitcoin_consensus_encoding::CompactSizeDecoder::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+  pub type bitcoin_consensus_encoding::CompactSizeDecoder::Error = <U as core::convert::TryFrom<T>>::Error [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::CompactSizeDecoder where U: core::convert::TryFrom<T>]
+  pub fn bitcoin_consensus_encoding::CompactSizeDecoder::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error> [impl: impl<T, U> core::convert::TryInto<U> for bitcoin_consensus_encoding::CompactSizeDecoder where U: core::convert::TryFrom<T>]
 impl<T> alloc::borrow::ToOwned for bitcoin_consensus_e
Risk score
Why this scored 15/100

Our methodology →
Potential impact 0/30
Exploitability 0/25
Stealth signal 0/15
Affected reach 0/15
Confidence 10/10
Evidence quality 5/5
Human-validated context
Community notes

Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
No validated notes yet.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.
What the developer wrote

What changed, and why it matters

Security signals we found

Evidence from the diff

Changed components

Why this scored 15/100

Community notes

Related watches

Merge rust-bitcoin/rust-bitcoin#6719: Release tracking PR: `consensus-encoding 1.2.0`

Merge rust-bitcoin/rust-bitcoin#6728: primitives: Add links in docs and update encoding trait names

primitives: Replace instances of old encoding trait names
