feat: migrate from Cedar to SpiceDB authorization system

This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.

Key changes:

- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization

This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.

Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.

19 files changed, 0 insertions, 9788 deletions

diff --git a/vendor/bytes/src/buf/buf_impl.rs b/vendor/bytes/src/buf/buf_impl.rs
deleted file mode 100644
index 192034fb..00000000
--- a/vendor/bytes/src/buf/buf_impl.rs
+++ /dev/null
@@ -1,2962 +0,0 @@
-#[cfg(feature = "std")]
-use crate::buf::{reader, Reader};
-use crate::buf::{take, Chain, Take};
-#[cfg(feature = "std")]
-use crate::{min_u64_usize, saturating_sub_usize_u64};
-use crate::{panic_advance, panic_does_not_fit, TryGetError};
-
-#[cfg(feature = "std")]
-use std::io::IoSlice;
-
-use alloc::boxed::Box;
-
-macro_rules! buf_try_get_impl {
-    ($this:ident, $typ:tt::$conv:tt) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
-
-        if $this.remaining() < SIZE {
-            return Err(TryGetError {
-                requested: SIZE,
-                available: $this.remaining(),
-            });
-        }
-
-        // try to convert directly from the bytes
-        // this Option<ret> trick is to avoid keeping a borrow on self
-        // when advance() is called (mut borrow) and to call bytes() only once
-        let ret = $this
-            .chunk()
-            .get(..SIZE)
-            .map(|src| unsafe { $typ::$conv(*(src as *const _ as *const [_; SIZE])) });
-
-        if let Some(ret) = ret {
-            // if the direct conversion was possible, advance and return
-            $this.advance(SIZE);
-            return Ok(ret);
-        } else {
-            // if not we copy the bytes in a temp buffer then convert
-            let mut buf = [0; SIZE];
-            $this.copy_to_slice(&mut buf); // (do the advance)
-            return Ok($typ::$conv(buf));
-        }
-    }};
-    (le => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
-
-        // The same trick as above does not improve the best case speed.
-        // It seems to be linked to the way the method is optimised by the compiler
-        let mut buf = [0; SIZE];
-
-        let subslice = match buf.get_mut(..$len_to_read) {
-            Some(subslice) => subslice,
-            None => panic_does_not_fit(SIZE, $len_to_read),
-        };
-
-        $this.try_copy_to_slice(subslice)?;
-        return Ok($typ::from_le_bytes(buf));
-    }};
-    (be => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
-
-        let slice_at = match SIZE.checked_sub($len_to_read) {
-            Some(slice_at) => slice_at,
-            None => panic_does_not_fit(SIZE, $len_to_read),
-        };
-
-        let mut buf = [0; SIZE];
-        $this.try_copy_to_slice(&mut buf[slice_at..])?;
-        return Ok($typ::from_be_bytes(buf));
-    }};
-}
-
-macro_rules! buf_get_impl {
-    ($this:ident, $typ:tt::$conv:tt) => {{
-        return (|| buf_try_get_impl!($this, $typ::$conv))()
-            .unwrap_or_else(|error| panic_advance(&error));
-    }};
-    (le => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        return (|| buf_try_get_impl!(le => $this, $typ, $len_to_read))()
-            .unwrap_or_else(|error| panic_advance(&error));
-    }};
-    (be => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        return (|| buf_try_get_impl!(be => $this, $typ, $len_to_read))()
-            .unwrap_or_else(|error| panic_advance(&error));
-    }};
-}
-
-// https://en.wikipedia.org/wiki/Sign_extension
-fn sign_extend(val: u64, nbytes: usize) -> i64 {
-    let shift = (8 - nbytes) * 8;
-    (val << shift) as i64 >> shift
-}
-
-/// Read bytes from a buffer.
-///
-/// A buffer stores bytes in memory such that read operations are infallible.
-/// The underlying storage may or may not be in contiguous memory. A `Buf` value
-/// is a cursor into the buffer. Reading from `Buf` advances the cursor
-/// position. It can be thought of as an efficient `Iterator` for collections of
-/// bytes.
-///
-/// The simplest `Buf` is a `&[u8]`.
-///
-/// ```
-/// use bytes::Buf;
-///
-/// let mut buf = &b"hello world"[..];
-///
-/// assert_eq!(b'h', buf.get_u8());
-/// assert_eq!(b'e', buf.get_u8());
-/// assert_eq!(b'l', buf.get_u8());
-///
-/// let mut rest = [0; 8];
-/// buf.copy_to_slice(&mut rest);
-///
-/// assert_eq!(&rest[..], &b"lo world"[..]);
-/// ```
-pub trait Buf {
-    /// Returns the number of bytes between the current position and the end of
-    /// the buffer.
-    ///
-    /// This value is greater than or equal to the length of the slice returned
-    /// by `chunk()`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"hello world"[..];
-    ///
-    /// assert_eq!(buf.remaining(), 11);
-    ///
-    /// buf.get_u8();
-    ///
-    /// assert_eq!(buf.remaining(), 10);
-    /// ```
-    ///
-    /// # Implementer notes
-    ///
-    /// Implementations of `remaining` should ensure that the return value does
-    /// not change unless a call is made to `advance` or any other function that
-    /// is documented to change the `Buf`'s current position.
-    fn remaining(&self) -> usize;
-
-    /// Returns a slice starting at the current position and of length between 0
-    /// and `Buf::remaining()`. Note that this *can* return a shorter slice (this
-    /// allows non-continuous internal representation).
-    ///
-    /// This is a lower level function. Most operations are done with other
-    /// functions.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"hello world"[..];
-    ///
-    /// assert_eq!(buf.chunk(), &b"hello world"[..]);
-    ///
-    /// buf.advance(6);
-    ///
-    /// assert_eq!(buf.chunk(), &b"world"[..]);
-    /// ```
-    ///
-    /// # Implementer notes
-    ///
-    /// This function should never panic. `chunk()` should return an empty
-    /// slice **if and only if** `remaining()` returns 0. In other words,
-    /// `chunk()` returning an empty slice implies that `remaining()` will
-    /// return 0 and `remaining()` returning 0 implies that `chunk()` will
-    /// return an empty slice.
-    // The `chunk` method was previously called `bytes`. This alias makes the rename
-    // more easily discoverable.
-    #[cfg_attr(docsrs, doc(alias = "bytes"))]
-    fn chunk(&self) -> &[u8];
-
-    /// Fills `dst` with potentially multiple slices starting at `self`'s
-    /// current position.
-    ///
-    /// If the `Buf` is backed by disjoint slices of bytes, `chunk_vectored` enables
-    /// fetching more than one slice at once. `dst` is a slice of `IoSlice`
-    /// references, enabling the slice to be directly used with [`writev`]
-    /// without any further conversion. The sum of the lengths of all the
-    /// buffers written to `dst` will be less than or equal to `Buf::remaining()`.
-    ///
-    /// The entries in `dst` will be overwritten, but the data **contained** by
-    /// the slices **will not** be modified. The return value is the number of
-    /// slices written to `dst`. If `Buf::remaining()` is non-zero, then this
-    /// writes at least one non-empty slice to `dst`.
-    ///
-    /// This is a lower level function. Most operations are done with other
-    /// functions.
-    ///
-    /// # Implementer notes
-    ///
-    /// This function should never panic. Once the end of the buffer is reached,
-    /// i.e., `Buf::remaining` returns 0, calls to `chunk_vectored` must return 0
-    /// without mutating `dst`.
-    ///
-    /// Implementations should also take care to properly handle being called
-    /// with `dst` being a zero length slice.
-    ///
-    /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
-        if dst.is_empty() {
-            return 0;
-        }
-
-        if self.has_remaining() {
-            dst[0] = IoSlice::new(self.chunk());
-            1
-        } else {
-            0
-        }
-    }
-
-    /// Advance the internal cursor of the Buf
-    ///
-    /// The next call to `chunk()` will return a slice starting `cnt` bytes
-    /// further into the underlying buffer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"hello world"[..];
-    ///
-    /// assert_eq!(buf.chunk(), &b"hello world"[..]);
-    ///
-    /// buf.advance(6);
-    ///
-    /// assert_eq!(buf.chunk(), &b"world"[..]);
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function **may** panic if `cnt > self.remaining()`.
-    ///
-    /// # Implementer notes
-    ///
-    /// It is recommended for implementations of `advance` to panic if `cnt >
-    /// self.remaining()`. If the implementation does not panic, the call must
-    /// behave as if `cnt == self.remaining()`.
-    ///
-    /// A call with `cnt == 0` should never panic and be a no-op.
-    fn advance(&mut self, cnt: usize);
-
-    /// Returns true if there are any more bytes to consume
-    ///
-    /// This is equivalent to `self.remaining() != 0`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"a"[..];
-    ///
-    /// assert!(buf.has_remaining());
-    ///
-    /// buf.get_u8();
-    ///
-    /// assert!(!buf.has_remaining());
-    /// ```
-    fn has_remaining(&self) -> bool {
-        self.remaining() > 0
-    }
-
-    /// Copies bytes from `self` into `dst`.
-    ///
-    /// The cursor is advanced by the number of bytes copied. `self` must have
-    /// enough remaining bytes to fill `dst`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"hello world"[..];
-    /// let mut dst = [0; 5];
-    ///
-    /// buf.copy_to_slice(&mut dst);
-    /// assert_eq!(&b"hello"[..], &dst);
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `self.remaining() < dst.len()`.
-    fn copy_to_slice(&mut self, dst: &mut [u8]) {
-        self.try_copy_to_slice(dst)
-            .unwrap_or_else(|error| panic_advance(&error));
-    }
-
-    /// Gets an unsigned 8 bit integer from `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08 hello"[..];
-    /// assert_eq!(8, buf.get_u8());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is no more remaining data in `self`.
-    fn get_u8(&mut self) -> u8 {
-        if self.remaining() < 1 {
-            panic_advance(&TryGetError {
-                requested: 1,
-                available: 0,
-            })
-        }
-        let ret = self.chunk()[0];
-        self.advance(1);
-        ret
-    }
-
-    /// Gets a signed 8 bit integer from `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08 hello"[..];
-    /// assert_eq!(8, buf.get_i8());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is no more remaining data in `self`.
-    fn get_i8(&mut self) -> i8 {
-        if self.remaining() < 1 {
-            panic_advance(&TryGetError {
-                requested: 1,
-                available: 0,
-            });
-        }
-        let ret = self.chunk()[0] as i8;
-        self.advance(1);
-        ret
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09 hello"[..];
-    /// assert_eq!(0x0809, buf.get_u16());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u16(&mut self) -> u16 {
-        buf_get_impl!(self, u16::from_be_bytes);
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x09\x08 hello"[..];
-    /// assert_eq!(0x0809, buf.get_u16_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u16_le(&mut self) -> u16 {
-        buf_get_impl!(self, u16::from_le_bytes);
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809, buf.get_u16_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u16_ne(&mut self) -> u16 {
-        buf_get_impl!(self, u16::from_ne_bytes);
-    }
-
-    /// Gets a signed 16 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09 hello"[..];
-    /// assert_eq!(0x0809, buf.get_i16());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i16(&mut self) -> i16 {
-        buf_get_impl!(self, i16::from_be_bytes);
-    }
-
-    /// Gets a signed 16 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x09\x08 hello"[..];
-    /// assert_eq!(0x0809, buf.get_i16_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i16_le(&mut self) -> i16 {
-        buf_get_impl!(self, i16::from_le_bytes);
-    }
-
-    /// Gets a signed 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809, buf.get_i16_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i16_ne(&mut self) -> i16 {
-        buf_get_impl!(self, i16::from_ne_bytes);
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
-    /// assert_eq!(0x0809A0A1, buf.get_u32());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u32(&mut self) -> u32 {
-        buf_get_impl!(self, u32::from_be_bytes);
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in the little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
-    /// assert_eq!(0x0809A0A1, buf.get_u32_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u32_le(&mut self) -> u32 {
-        buf_get_impl!(self, u32::from_le_bytes);
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809A0A1, buf.get_u32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u32_ne(&mut self) -> u32 {
-        buf_get_impl!(self, u32::from_ne_bytes);
-    }
-
-    /// Gets a signed 32 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
-    /// assert_eq!(0x0809A0A1, buf.get_i32());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i32(&mut self) -> i32 {
-        buf_get_impl!(self, i32::from_be_bytes);
-    }
-
-    /// Gets a signed 32 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
-    /// assert_eq!(0x0809A0A1, buf.get_i32_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i32_le(&mut self) -> i32 {
-        buf_get_impl!(self, i32::from_le_bytes);
-    }
-
-    /// Gets a signed 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809A0A1, buf.get_i32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i32_ne(&mut self) -> i32 {
-        buf_get_impl!(self, i32::from_ne_bytes);
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
-    /// assert_eq!(0x0102030405060708, buf.get_u64());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u64(&mut self) -> u64 {
-        buf_get_impl!(self, u64::from_be_bytes);
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(0x0102030405060708, buf.get_u64_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u64_le(&mut self) -> u64 {
-        buf_get_impl!(self, u64::from_le_bytes);
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x0102030405060708, buf.get_u64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u64_ne(&mut self) -> u64 {
-        buf_get_impl!(self, u64::from_ne_bytes);
-    }
-
-    /// Gets a signed 64 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
-    /// assert_eq!(0x0102030405060708, buf.get_i64());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i64(&mut self) -> i64 {
-        buf_get_impl!(self, i64::from_be_bytes);
-    }
-
-    /// Gets a signed 64 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(0x0102030405060708, buf.get_i64_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i64_le(&mut self) -> i64 {
-        buf_get_impl!(self, i64::from_le_bytes);
-    }
-
-    /// Gets a signed 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x0102030405060708, buf.get_i64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i64_ne(&mut self) -> i64 {
-        buf_get_impl!(self, i64::from_ne_bytes);
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u128(&mut self) -> u128 {
-        buf_get_impl!(self, u128::from_be_bytes);
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u128_le(&mut self) -> u128 {
-        buf_get_impl!(self, u128::from_le_bytes);
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u128_ne(&mut self) -> u128 {
-        buf_get_impl!(self, u128::from_ne_bytes);
-    }
-
-    /// Gets a signed 128 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i128(&mut self) -> i128 {
-        buf_get_impl!(self, i128::from_be_bytes);
-    }
-
-    /// Gets a signed 128 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i128_le(&mut self) -> i128 {
-        buf_get_impl!(self, i128::from_le_bytes);
-    }
-
-    /// Gets a signed 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i128_ne(&mut self) -> i128 {
-        buf_get_impl!(self, i128::from_ne_bytes);
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03 hello"[..];
-    /// assert_eq!(0x010203, buf.get_uint(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_uint(&mut self, nbytes: usize) -> u64 {
-        buf_get_impl!(be => self, u64, nbytes);
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x03\x02\x01 hello"[..];
-    /// assert_eq!(0x010203, buf.get_uint_le(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_uint_le(&mut self, nbytes: usize) -> u64 {
-        buf_get_impl!(le => self, u64, nbytes);
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x010203, buf.get_uint_ne(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_uint_ne(&mut self, nbytes: usize) -> u64 {
-        if cfg!(target_endian = "big") {
-            self.get_uint(nbytes)
-        } else {
-            self.get_uint_le(nbytes)
-        }
-    }
-
-    /// Gets a signed n-byte integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03 hello"[..];
-    /// assert_eq!(0x010203, buf.get_int(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_int(&mut self, nbytes: usize) -> i64 {
-        sign_extend(self.get_uint(nbytes), nbytes)
-    }
-
-    /// Gets a signed n-byte integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x03\x02\x01 hello"[..];
-    /// assert_eq!(0x010203, buf.get_int_le(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_int_le(&mut self, nbytes: usize) -> i64 {
-        sign_extend(self.get_uint_le(nbytes), nbytes)
-    }
-
-    /// Gets a signed n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x010203, buf.get_int_ne(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_int_ne(&mut self, nbytes: usize) -> i64 {
-        if cfg!(target_endian = "big") {
-            self.get_int(nbytes)
-        } else {
-            self.get_int_le(nbytes)
-        }
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
-    /// assert_eq!(1.2f32, buf.get_f32());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f32(&mut self) -> f32 {
-        f32::from_bits(self.get_u32())
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
-    /// assert_eq!(1.2f32, buf.get_f32_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f32_le(&mut self) -> f32 {
-        f32::from_bits(self.get_u32_le())
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\x99\x99\x9A hello",
-    ///     false => b"\x9A\x99\x99\x3F hello",
-    /// };
-    /// assert_eq!(1.2f32, buf.get_f32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f32_ne(&mut self) -> f32 {
-        f32::from_bits(self.get_u32_ne())
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
-    /// assert_eq!(1.2f64, buf.get_f64());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f64(&mut self) -> f64 {
-        f64::from_bits(self.get_u64())
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
-    /// assert_eq!(1.2f64, buf.get_f64_le());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f64_le(&mut self) -> f64 {
-        f64::from_bits(self.get_u64_le())
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
-    ///     false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
-    /// };
-    /// assert_eq!(1.2f64, buf.get_f64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f64_ne(&mut self) -> f64 {
-        f64::from_bits(self.get_u64_ne())
-    }
-
-    /// Copies bytes from `self` into `dst`.
-    ///
-    /// The cursor is advanced by the number of bytes copied. `self` must have
-    /// enough remaining bytes to fill `dst`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"hello world"[..];
-    /// let mut dst = [0; 5];
-    ///
-    /// assert_eq!(Ok(()), buf.try_copy_to_slice(&mut dst));
-    /// assert_eq!(&b"hello"[..], &dst);
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"hello world"[..];
-    /// let mut dst = [0; 12];
-    ///
-    /// assert_eq!(Err(TryGetError{requested: 12, available: 11}), buf.try_copy_to_slice(&mut dst));
-    /// assert_eq!(11, buf.remaining());
-    /// ```
-    fn try_copy_to_slice(&mut self, mut dst: &mut [u8]) -> Result<(), TryGetError> {
-        if self.remaining() < dst.len() {
-            return Err(TryGetError {
-                requested: dst.len(),
-                available: self.remaining(),
-            });
-        }
-
-        while !dst.is_empty() {
-            let src = self.chunk();
-            let cnt = usize::min(src.len(), dst.len());
-
-            dst[..cnt].copy_from_slice(&src[..cnt]);
-            dst = &mut dst[cnt..];
-
-            self.advance(cnt);
-        }
-        Ok(())
-    }
-
-    /// Gets an unsigned 8 bit integer from `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08 hello"[..];
-    /// assert_eq!(Ok(0x08_u8), buf.try_get_u8());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b""[..];
-    /// assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8());
-    /// ```
-    fn try_get_u8(&mut self) -> Result<u8, TryGetError> {
-        if self.remaining() < 1 {
-            return Err(TryGetError {
-                requested: 1,
-                available: self.remaining(),
-            });
-        }
-        let ret = self.chunk()[0];
-        self.advance(1);
-        Ok(ret)
-    }
-
-    /// Gets a signed 8 bit integer from `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08 hello"[..];
-    /// assert_eq!(Ok(0x08_i8), buf.try_get_i8());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b""[..];
-    /// assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_i8());
-    /// ```
-    fn try_get_i8(&mut self) -> Result<i8, TryGetError> {
-        if self.remaining() < 1 {
-            return Err(TryGetError {
-                requested: 1,
-                available: self.remaining(),
-            });
-        }
-        let ret = self.chunk()[0] as i8;
-        self.advance(1);
-        Ok(ret)
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09 hello"[..];
-    /// assert_eq!(Ok(0x0809_u16), buf.try_get_u16());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_u16(&mut self) -> Result<u16, TryGetError> {
-        buf_try_get_impl!(self, u16::from_be_bytes)
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x09\x08 hello"[..];
-    /// assert_eq!(Ok(0x0809_u16), buf.try_get_u16_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16_le());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_u16_le(&mut self) -> Result<u16, TryGetError> {
-        buf_try_get_impl!(self, u16::from_le_bytes)
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(Ok(0x0809_u16), buf.try_get_u16_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16_ne());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_u16_ne(&mut self) -> Result<u16, TryGetError> {
-        buf_try_get_impl!(self, u16::from_ne_bytes)
-    }
-
-    /// Gets a signed 16 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09 hello"[..];
-    /// assert_eq!(Ok(0x0809_i16), buf.try_get_i16());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_i16(&mut self) -> Result<i16, TryGetError> {
-        buf_try_get_impl!(self, i16::from_be_bytes)
-    }
-
-    /// Gets an signed 16 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x09\x08 hello"[..];
-    /// assert_eq!(Ok(0x0809_i16), buf.try_get_i16_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16_le());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_i16_le(&mut self) -> Result<i16, TryGetError> {
-        buf_try_get_impl!(self, i16::from_le_bytes)
-    }
-
-    /// Gets a signed 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(Ok(0x0809_i16), buf.try_get_i16_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16_ne());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_i16_ne(&mut self) -> Result<i16, TryGetError> {
-        buf_try_get_impl!(self, i16::from_ne_bytes)
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
-    /// assert_eq!(Ok(0x0809A0A1), buf.try_get_u32());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_u32(&mut self) -> Result<u32, TryGetError> {
-        buf_try_get_impl!(self, u32::from_be_bytes)
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
-    /// assert_eq!(Ok(0x0809A0A1_u32), buf.try_get_u32_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x09\xA0"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32_le());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_u32_le(&mut self) -> Result<u32, TryGetError> {
-        buf_try_get_impl!(self, u32::from_le_bytes)
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(Ok(0x0809A0A1_u32), buf.try_get_u32_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x09\xA0"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32_ne());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_u32_ne(&mut self) -> Result<u32, TryGetError> {
-        buf_try_get_impl!(self, u32::from_ne_bytes)
-    }
-
-    /// Gets a signed 32 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
-    /// assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_i32(&mut self) -> Result<i32, TryGetError> {
-        buf_try_get_impl!(self, i32::from_be_bytes)
-    }
-
-    /// Gets a signed 32 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
-    /// assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x09\xA0"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32_le());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_i32_le(&mut self) -> Result<i32, TryGetError> {
-        buf_try_get_impl!(self, i32::from_le_bytes)
-    }
-
-    /// Gets a signed 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x09\xA0"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32_ne());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_i32_ne(&mut self) -> Result<i32, TryGetError> {
-        buf_try_get_impl!(self, i32::from_ne_bytes)
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
-    /// assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_u64(&mut self) -> Result<u64, TryGetError> {
-        buf_try_get_impl!(self, u64::from_be_bytes)
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64_le());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_u64_le(&mut self) -> Result<u64, TryGetError> {
-        buf_try_get_impl!(self, u64::from_le_bytes)
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64_ne());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_u64_ne(&mut self) -> Result<u64, TryGetError> {
-        buf_try_get_impl!(self, u64::from_ne_bytes)
-    }
-
-    /// Gets a signed 64 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
-    /// assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_i64(&mut self) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(self, i64::from_be_bytes)
-    }
-
-    /// Gets a signed 64 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64_le());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_i64_le(&mut self) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(self, i64::from_le_bytes)
-    }
-
-    /// Gets a signed 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64_ne());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_i64_ne(&mut self) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(self, i64::from_ne_bytes)
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
-    /// assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_u128(&mut self) -> Result<u128, TryGetError> {
-        buf_try_get_impl!(self, u128::from_be_bytes)
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128_le());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_u128_le(&mut self) -> Result<u128, TryGetError> {
-        buf_try_get_impl!(self, u128::from_le_bytes)
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128_ne());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_u128_ne(&mut self) -> Result<u128, TryGetError> {
-        buf_try_get_impl!(self, u128::from_ne_bytes)
-    }
-
-    /// Gets a signed 128 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
-    /// assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_i128(&mut self) -> Result<i128, TryGetError> {
-        buf_try_get_impl!(self, i128::from_be_bytes)
-    }
-
-    /// Gets a signed 128 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128_le());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_i128_le(&mut self) -> Result<i128, TryGetError> {
-        buf_try_get_impl!(self, i128::from_le_bytes)
-    }
-
-    /// Gets a signed 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128_ne());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_i128_ne(&mut self) -> Result<i128, TryGetError> {
-        buf_try_get_impl!(self, i128::from_ne_bytes)
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03 hello"[..];
-    /// assert_eq!(Ok(0x010203_u64), buf.try_get_uint(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` > 8.
-    fn try_get_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-        buf_try_get_impl!(be => self, u64, nbytes);
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x010203_u64), buf.try_get_uint_le(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint_le(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` > 8.
-    fn try_get_uint_le(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-        buf_try_get_impl!(le => self, u64, nbytes);
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x010203_u64), buf.try_get_uint_ne(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03",
-    ///     false => b"\x03\x02\x01",
-    /// };
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint_ne(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` is greater than 8.
-    fn try_get_uint_ne(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-        if cfg!(target_endian = "big") {
-            self.try_get_uint(nbytes)
-        } else {
-            self.try_get_uint_le(nbytes)
-        }
-    }
-
-    /// Gets a signed n-byte integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03 hello"[..];
-    /// assert_eq!(Ok(0x010203_i64), buf.try_get_int(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` is greater than 8.
-    fn try_get_int(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(be => self, i64, nbytes);
-    }
-
-    /// Gets a signed n-byte integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x010203_i64), buf.try_get_int_le(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int_le(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` is greater than 8.
-    fn try_get_int_le(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(le => self, i64, nbytes);
-    }
-
-    /// Gets a signed n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x010203_i64), buf.try_get_int_ne(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03",
-    ///     false => b"\x03\x02\x01",
-    /// };
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int_ne(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` is greater than 8.
-    fn try_get_int_ne(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-        if cfg!(target_endian = "big") {
-            self.try_get_int(nbytes)
-        } else {
-            self.try_get_int_le(nbytes)
-        }
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
-    /// assert_eq!(1.2f32, buf.get_f32());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\x99\x99"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_f32(&mut self) -> Result<f32, TryGetError> {
-        Ok(f32::from_bits(self.try_get_u32()?))
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
-    /// assert_eq!(1.2f32, buf.get_f32_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\x99\x99"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32_le());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_f32_le(&mut self) -> Result<f32, TryGetError> {
-        Ok(f32::from_bits(self.try_get_u32_le()?))
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\x99\x99\x9A hello",
-    ///     false => b"\x9A\x99\x99\x3F hello",
-    /// };
-    /// assert_eq!(1.2f32, buf.get_f32_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\x99\x99"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32_ne());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_f32_ne(&mut self) -> Result<f32, TryGetError> {
-        Ok(f32::from_bits(self.try_get_u32_ne()?))
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
-    /// assert_eq!(1.2f64, buf.get_f64());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_f64(&mut self) -> Result<f64, TryGetError> {
-        Ok(f64::from_bits(self.try_get_u64()?))
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
-    /// assert_eq!(1.2f64, buf.get_f64_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64_le());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_f64_le(&mut self) -> Result<f64, TryGetError> {
-        Ok(f64::from_bits(self.try_get_u64_le()?))
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
-    ///     false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
-    /// };
-    /// assert_eq!(1.2f64, buf.get_f64_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64_ne());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_f64_ne(&mut self) -> Result<f64, TryGetError> {
-        Ok(f64::from_bits(self.try_get_u64_ne()?))
-    }
-
-    /// Consumes `len` bytes inside self and returns new instance of `Bytes`
-    /// with this data.
-    ///
-    /// This function may be optimized by the underlying type to avoid actual
-    /// copies. For example, `Bytes` implementation will do a shallow copy
-    /// (ref-count increment).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let bytes = (&b"hello world"[..]).copy_to_bytes(5);
-    /// assert_eq!(&bytes[..], &b"hello"[..]);
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `len > self.remaining()`.
-    fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
-        use super::BufMut;
-
-        if self.remaining() < len {
-            panic_advance(&TryGetError {
-                requested: len,
-                available: self.remaining(),
-            });
-        }
-
-        let mut ret = crate::BytesMut::with_capacity(len);
-        ret.put(self.take(len));
-        ret.freeze()
-    }
-
-    /// Creates an adaptor which will read at most `limit` bytes from `self`.
-    ///
-    /// This function returns a new instance of `Buf` which will read at most
-    /// `limit` bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{Buf, BufMut};
-    ///
-    /// let mut buf = b"hello world"[..].take(5);
-    /// let mut dst = vec![];
-    ///
-    /// dst.put(&mut buf);
-    /// assert_eq!(dst, b"hello");
-    ///
-    /// let mut buf = buf.into_inner();
-    /// dst.clear();
-    /// dst.put(&mut buf);
-    /// assert_eq!(dst, b" world");
-    /// ```
-    fn take(self, limit: usize) -> Take<Self>
-    where
-        Self: Sized,
-    {
-        take::new(self, limit)
-    }
-
-    /// Creates an adaptor which will chain this buffer with another.
-    ///
-    /// The returned `Buf` instance will first consume all bytes from `self`.
-    /// Afterwards the output is equivalent to the output of next.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut chain = b"hello "[..].chain(&b"world"[..]);
-    ///
-    /// let full = chain.copy_to_bytes(11);
-    /// assert_eq!(full.chunk(), b"hello world");
-    /// ```
-    fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
-    where
-        Self: Sized,
-    {
-        Chain::new(self, next)
-    }
-
-    /// Creates an adaptor which implements the `Read` trait for `self`.
-    ///
-    /// This function returns a new value which implements `Read` by adapting
-    /// the `Read` trait functions to the `Buf` trait functions. Given that
-    /// `Buf` operations are infallible, none of the `Read` functions will
-    /// return with `Err`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{Bytes, Buf};
-    /// use std::io::Read;
-    ///
-    /// let buf = Bytes::from("hello world");
-    ///
-    /// let mut reader = buf.reader();
-    /// let mut dst = [0; 1024];
-    ///
-    /// let num = reader.read(&mut dst).unwrap();
-    ///
-    /// assert_eq!(11, num);
-    /// assert_eq!(&dst[..11], &b"hello world"[..]);
-    /// ```
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-    fn reader(self) -> Reader<Self>
-    where
-        Self: Sized,
-    {
-        reader::new(self)
-    }
-}
-
-macro_rules! deref_forward_buf {
-    () => {
-        #[inline]
-        fn remaining(&self) -> usize {
-            (**self).remaining()
-        }
-
-        #[inline]
-        fn chunk(&self) -> &[u8] {
-            (**self).chunk()
-        }
-
-        #[cfg(feature = "std")]
-        #[inline]
-        fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
-            (**self).chunks_vectored(dst)
-        }
-
-        #[inline]
-        fn advance(&mut self, cnt: usize) {
-            (**self).advance(cnt)
-        }
-
-        #[inline]
-        fn has_remaining(&self) -> bool {
-            (**self).has_remaining()
-        }
-
-        #[inline]
-        fn copy_to_slice(&mut self, dst: &mut [u8]) {
-            (**self).copy_to_slice(dst)
-        }
-
-        #[inline]
-        fn get_u8(&mut self) -> u8 {
-            (**self).get_u8()
-        }
-
-        #[inline]
-        fn get_i8(&mut self) -> i8 {
-            (**self).get_i8()
-        }
-
-        #[inline]
-        fn get_u16(&mut self) -> u16 {
-            (**self).get_u16()
-        }
-
-        #[inline]
-        fn get_u16_le(&mut self) -> u16 {
-            (**self).get_u16_le()
-        }
-
-        #[inline]
-        fn get_u16_ne(&mut self) -> u16 {
-            (**self).get_u16_ne()
-        }
-
-        #[inline]
-        fn get_i16(&mut self) -> i16 {
-            (**self).get_i16()
-        }
-
-        #[inline]
-        fn get_i16_le(&mut self) -> i16 {
-            (**self).get_i16_le()
-        }
-
-        #[inline]
-        fn get_i16_ne(&mut self) -> i16 {
-            (**self).get_i16_ne()
-        }
-
-        #[inline]
-        fn get_u32(&mut self) -> u32 {
-            (**self).get_u32()
-        }
-
-        #[inline]
-        fn get_u32_le(&mut self) -> u32 {
-            (**self).get_u32_le()
-        }
-
-        #[inline]
-        fn get_u32_ne(&mut self) -> u32 {
-            (**self).get_u32_ne()
-        }
-
-        #[inline]
-        fn get_i32(&mut self) -> i32 {
-            (**self).get_i32()
-        }
-
-        #[inline]
-        fn get_i32_le(&mut self) -> i32 {
-            (**self).get_i32_le()
-        }
-
-        #[inline]
-        fn get_i32_ne(&mut self) -> i32 {
-            (**self).get_i32_ne()
-        }
-
-        #[inline]
-        fn get_u64(&mut self) -> u64 {
-            (**self).get_u64()
-        }
-
-        #[inline]
-        fn get_u64_le(&mut self) -> u64 {
-            (**self).get_u64_le()
-        }
-
-        #[inline]
-        fn get_u64_ne(&mut self) -> u64 {
-            (**self).get_u64_ne()
-        }
-
-        #[inline]
-        fn get_i64(&mut self) -> i64 {
-            (**self).get_i64()
-        }
-
-        #[inline]
-        fn get_i64_le(&mut self) -> i64 {
-            (**self).get_i64_le()
-        }
-
-        #[inline]
-        fn get_i64_ne(&mut self) -> i64 {
-            (**self).get_i64_ne()
-        }
-
-        #[inline]
-        fn get_u128(&mut self) -> u128 {
-            (**self).get_u128()
-        }
-
-        #[inline]
-        fn get_u128_le(&mut self) -> u128 {
-            (**self).get_u128_le()
-        }
-
-        #[inline]
-        fn get_u128_ne(&mut self) -> u128 {
-            (**self).get_u128_ne()
-        }
-
-        #[inline]
-        fn get_i128(&mut self) -> i128 {
-            (**self).get_i128()
-        }
-
-        #[inline]
-        fn get_i128_le(&mut self) -> i128 {
-            (**self).get_i128_le()
-        }
-
-        #[inline]
-        fn get_i128_ne(&mut self) -> i128 {
-            (**self).get_i128_ne()
-        }
-
-        #[inline]
-        fn get_uint(&mut self, nbytes: usize) -> u64 {
-            (**self).get_uint(nbytes)
-        }
-
-        #[inline]
-        fn get_uint_le(&mut self, nbytes: usize) -> u64 {
-            (**self).get_uint_le(nbytes)
-        }
-
-        #[inline]
-        fn get_uint_ne(&mut self, nbytes: usize) -> u64 {
-            (**self).get_uint_ne(nbytes)
-        }
-
-        #[inline]
-        fn get_int(&mut self, nbytes: usize) -> i64 {
-            (**self).get_int(nbytes)
-        }
-
-        #[inline]
-        fn get_int_le(&mut self, nbytes: usize) -> i64 {
-            (**self).get_int_le(nbytes)
-        }
-
-        #[inline]
-        fn get_int_ne(&mut self, nbytes: usize) -> i64 {
-            (**self).get_int_ne(nbytes)
-        }
-
-        #[inline]
-        fn get_f32(&mut self) -> f32 {
-            (**self).get_f32()
-        }
-
-        #[inline]
-        fn get_f32_le(&mut self) -> f32 {
-            (**self).get_f32_le()
-        }
-
-        #[inline]
-        fn get_f32_ne(&mut self) -> f32 {
-            (**self).get_f32_ne()
-        }
-
-        #[inline]
-        fn get_f64(&mut self) -> f64 {
-            (**self).get_f64()
-        }
-
-        #[inline]
-        fn get_f64_le(&mut self) -> f64 {
-            (**self).get_f64_le()
-        }
-
-        #[inline]
-        fn get_f64_ne(&mut self) -> f64 {
-            (**self).get_f64_ne()
-        }
-
-        #[inline]
-        fn try_copy_to_slice(&mut self, dst: &mut [u8]) -> Result<(), TryGetError> {
-            (**self).try_copy_to_slice(dst)
-        }
-
-        #[inline]
-        fn try_get_u8(&mut self) -> Result<u8, TryGetError> {
-            (**self).try_get_u8()
-        }
-
-        #[inline]
-        fn try_get_i8(&mut self) -> Result<i8, TryGetError> {
-            (**self).try_get_i8()
-        }
-
-        #[inline]
-        fn try_get_u16(&mut self) -> Result<u16, TryGetError> {
-            (**self).try_get_u16()
-        }
-
-        #[inline]
-        fn try_get_u16_le(&mut self) -> Result<u16, TryGetError> {
-            (**self).try_get_u16_le()
-        }
-
-        #[inline]
-        fn try_get_u16_ne(&mut self) -> Result<u16, TryGetError> {
-            (**self).try_get_u16_ne()
-        }
-
-        #[inline]
-        fn try_get_i16(&mut self) -> Result<i16, TryGetError> {
-            (**self).try_get_i16()
-        }
-
-        #[inline]
-        fn try_get_i16_le(&mut self) -> Result<i16, TryGetError> {
-            (**self).try_get_i16_le()
-        }
-
-        #[inline]
-        fn try_get_i16_ne(&mut self) -> Result<i16, TryGetError> {
-            (**self).try_get_i16_ne()
-        }
-
-        #[inline]
-        fn try_get_u32(&mut self) -> Result<u32, TryGetError> {
-            (**self).try_get_u32()
-        }
-
-        #[inline]
-        fn try_get_u32_le(&mut self) -> Result<u32, TryGetError> {
-            (**self).try_get_u32_le()
-        }
-
-        #[inline]
-        fn try_get_u32_ne(&mut self) -> Result<u32, TryGetError> {
-            (**self).try_get_u32_ne()
-        }
-
-        #[inline]
-        fn try_get_i32(&mut self) -> Result<i32, TryGetError> {
-            (**self).try_get_i32()
-        }
-
-        #[inline]
-        fn try_get_i32_le(&mut self) -> Result<i32, TryGetError> {
-            (**self).try_get_i32_le()
-        }
-
-        #[inline]
-        fn try_get_i32_ne(&mut self) -> Result<i32, TryGetError> {
-            (**self).try_get_i32_ne()
-        }
-
-        #[inline]
-        fn try_get_u64(&mut self) -> Result<u64, TryGetError> {
-            (**self).try_get_u64()
-        }
-
-        #[inline]
-        fn try_get_u64_le(&mut self) -> Result<u64, TryGetError> {
-            (**self).try_get_u64_le()
-        }
-
-        #[inline]
-        fn try_get_u64_ne(&mut self) -> Result<u64, TryGetError> {
-            (**self).try_get_u64_ne()
-        }
-
-        #[inline]
-        fn try_get_i64(&mut self) -> Result<i64, TryGetError> {
-            (**self).try_get_i64()
-        }
-
-        #[inline]
-        fn try_get_i64_le(&mut self) -> Result<i64, TryGetError> {
-            (**self).try_get_i64_le()
-        }
-
-        #[inline]
-        fn try_get_i64_ne(&mut self) -> Result<i64, TryGetError> {
-            (**self).try_get_i64_ne()
-        }
-
-        #[inline]
-        fn try_get_u128(&mut self) -> Result<u128, TryGetError> {
-            (**self).try_get_u128()
-        }
-
-        #[inline]
-        fn try_get_u128_le(&mut self) -> Result<u128, TryGetError> {
-            (**self).try_get_u128_le()
-        }
-
-        #[inline]
-        fn try_get_u128_ne(&mut self) -> Result<u128, TryGetError> {
-            (**self).try_get_u128_ne()
-        }
-
-        #[inline]
-        fn try_get_i128(&mut self) -> Result<i128, TryGetError> {
-            (**self).try_get_i128()
-        }
-
-        #[inline]
-        fn try_get_i128_le(&mut self) -> Result<i128, TryGetError> {
-            (**self).try_get_i128_le()
-        }
-
-        #[inline]
-        fn try_get_i128_ne(&mut self) -> Result<i128, TryGetError> {
-            (**self).try_get_i128_ne()
-        }
-
-        #[inline]
-        fn try_get_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-            (**self).try_get_uint(nbytes)
-        }
-
-        #[inline]
-        fn try_get_uint_le(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-            (**self).try_get_uint_le(nbytes)
-        }
-
-        #[inline]
-        fn try_get_uint_ne(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-            (**self).try_get_uint_ne(nbytes)
-        }
-
-        #[inline]
-        fn try_get_int(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-            (**self).try_get_int(nbytes)
-        }
-
-        #[inline]
-        fn try_get_int_le(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-            (**self).try_get_int_le(nbytes)
-        }
-
-        #[inline]
-        fn try_get_int_ne(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-            (**self).try_get_int_ne(nbytes)
-        }
-
-        #[inline]
-        fn try_get_f32(&mut self) -> Result<f32, TryGetError> {
-            (**self).try_get_f32()
-        }
-
-        #[inline]
-        fn try_get_f32_le(&mut self) -> Result<f32, TryGetError> {
-            (**self).try_get_f32_le()
-        }
-
-        #[inline]
-        fn try_get_f32_ne(&mut self) -> Result<f32, TryGetError> {
-            (**self).try_get_f32_ne()
-        }
-
-        #[inline]
-        fn try_get_f64(&mut self) -> Result<f64, TryGetError> {
-            (**self).try_get_f64()
-        }
-
-        #[inline]
-        fn try_get_f64_le(&mut self) -> Result<f64, TryGetError> {
-            (**self).try_get_f64_le()
-        }
-
-        #[inline]
-        fn try_get_f64_ne(&mut self) -> Result<f64, TryGetError> {
-            (**self).try_get_f64_ne()
-        }
-
-        #[inline]
-        fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
-            (**self).copy_to_bytes(len)
-        }
-    };
-}
-
-impl<T: Buf + ?Sized> Buf for &mut T {
-    deref_forward_buf!();
-}
-
-impl<T: Buf + ?Sized> Buf for Box<T> {
-    deref_forward_buf!();
-}
-
-impl Buf for &[u8] {
-    #[inline]
-    fn remaining(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk(&self) -> &[u8] {
-        self
-    }
-
-    #[inline]
-    fn advance(&mut self, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        *self = &self[cnt..];
-    }
-
-    #[inline]
-    fn copy_to_slice(&mut self, dst: &mut [u8]) {
-        if self.len() < dst.len() {
-            panic_advance(&TryGetError {
-                requested: dst.len(),
-                available: self.len(),
-            });
-        }
-
-        dst.copy_from_slice(&self[..dst.len()]);
-        self.advance(dst.len());
-    }
-}
-
-#[cfg(feature = "std")]
-impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
-    #[inline]
-    fn remaining(&self) -> usize {
-        saturating_sub_usize_u64(self.get_ref().as_ref().len(), self.position())
-    }
-
-    #[inline]
-    fn chunk(&self) -> &[u8] {
-        let slice = self.get_ref().as_ref();
-        let pos = min_u64_usize(self.position(), slice.len());
-        &slice[pos..]
-    }
-
-    #[inline]
-    fn advance(&mut self, cnt: usize) {
-        let len = self.get_ref().as_ref().len();
-        let pos = self.position();
-
-        // We intentionally allow `cnt == 0` here even if `pos > len`.
-        let max_cnt = saturating_sub_usize_u64(len, pos);
-        if cnt > max_cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: max_cnt,
-            });
-        }
-
-        // This will not overflow because either `cnt == 0` or the sum is not
-        // greater than `len`.
-        self.set_position(pos + cnt as u64);
-    }
-}
-
-// The existence of this function makes the compiler catch if the Buf
-// trait is "object-safe" or not.
-fn _assert_trait_object(_b: &dyn Buf) {}
diff --git a/vendor/bytes/src/buf/buf_mut.rs b/vendor/bytes/src/buf/buf_mut.rs
deleted file mode 100644
index 26645c6a..00000000
--- a/vendor/bytes/src/buf/buf_mut.rs
+++ /dev/null
@@ -1,1671 +0,0 @@
-use crate::buf::{limit, Chain, Limit, UninitSlice};
-#[cfg(feature = "std")]
-use crate::buf::{writer, Writer};
-use crate::{panic_advance, panic_does_not_fit, TryGetError};
-
-use core::{mem, ptr, usize};
-
-use alloc::{boxed::Box, vec::Vec};
-
-/// A trait for values that provide sequential write access to bytes.
-///
-/// Write bytes to a buffer
-///
-/// A buffer stores bytes in memory such that write operations are infallible.
-/// The underlying storage may or may not be in contiguous memory. A `BufMut`
-/// value is a cursor into the buffer. Writing to `BufMut` advances the cursor
-/// position.
-///
-/// The simplest `BufMut` is a `Vec<u8>`.
-///
-/// ```
-/// use bytes::BufMut;
-///
-/// let mut buf = vec![];
-///
-/// buf.put(&b"hello world"[..]);
-///
-/// assert_eq!(buf, b"hello world");
-/// ```
-pub unsafe trait BufMut {
-    /// Returns the number of bytes that can be written from the current
-    /// position until the end of the buffer is reached.
-    ///
-    /// This value is greater than or equal to the length of the slice returned
-    /// by `chunk_mut()`.
-    ///
-    /// Writing to a `BufMut` may involve allocating more memory on the fly.
-    /// Implementations may fail before reaching the number of bytes indicated
-    /// by this method if they encounter an allocation failure.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut dst = [0; 10];
-    /// let mut buf = &mut dst[..];
-    ///
-    /// let original_remaining = buf.remaining_mut();
-    /// buf.put(&b"hello"[..]);
-    ///
-    /// assert_eq!(original_remaining - 5, buf.remaining_mut());
-    /// ```
-    ///
-    /// # Implementer notes
-    ///
-    /// Implementations of `remaining_mut` should ensure that the return value
-    /// does not change unless a call is made to `advance_mut` or any other
-    /// function that is documented to change the `BufMut`'s current position.
-    ///
-    /// # Note
-    ///
-    /// `remaining_mut` may return value smaller than actual available space.
-    fn remaining_mut(&self) -> usize;
-
-    /// Advance the internal cursor of the BufMut
-    ///
-    /// The next call to `chunk_mut` will return a slice starting `cnt` bytes
-    /// further into the underlying buffer.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that the next `cnt` bytes of `chunk` are
-    /// initialized.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = Vec::with_capacity(16);
-    ///
-    /// // Write some data
-    /// buf.chunk_mut()[0..2].copy_from_slice(b"he");
-    /// unsafe { buf.advance_mut(2) };
-    ///
-    /// // write more bytes
-    /// buf.chunk_mut()[0..3].copy_from_slice(b"llo");
-    ///
-    /// unsafe { buf.advance_mut(3); }
-    ///
-    /// assert_eq!(5, buf.len());
-    /// assert_eq!(buf, b"hello");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function **may** panic if `cnt > self.remaining_mut()`.
-    ///
-    /// # Implementer notes
-    ///
-    /// It is recommended for implementations of `advance_mut` to panic if
-    /// `cnt > self.remaining_mut()`. If the implementation does not panic,
-    /// the call must behave as if `cnt == self.remaining_mut()`.
-    ///
-    /// A call with `cnt == 0` should never panic and be a no-op.
-    unsafe fn advance_mut(&mut self, cnt: usize);
-
-    /// Returns true if there is space in `self` for more bytes.
-    ///
-    /// This is equivalent to `self.remaining_mut() != 0`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut dst = [0; 5];
-    /// let mut buf = &mut dst[..];
-    ///
-    /// assert!(buf.has_remaining_mut());
-    ///
-    /// buf.put(&b"hello"[..]);
-    ///
-    /// assert!(!buf.has_remaining_mut());
-    /// ```
-    #[inline]
-    fn has_remaining_mut(&self) -> bool {
-        self.remaining_mut() > 0
-    }
-
-    /// Returns a mutable slice starting at the current BufMut position and of
-    /// length between 0 and `BufMut::remaining_mut()`. Note that this *can* be shorter than the
-    /// whole remainder of the buffer (this allows non-continuous implementation).
-    ///
-    /// This is a lower level function. Most operations are done with other
-    /// functions.
-    ///
-    /// The returned byte slice may represent uninitialized memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = Vec::with_capacity(16);
-    ///
-    /// unsafe {
-    ///     // MaybeUninit::as_mut_ptr
-    ///     buf.chunk_mut()[0..].as_mut_ptr().write(b'h');
-    ///     buf.chunk_mut()[1..].as_mut_ptr().write(b'e');
-    ///
-    ///     buf.advance_mut(2);
-    ///
-    ///     buf.chunk_mut()[0..].as_mut_ptr().write(b'l');
-    ///     buf.chunk_mut()[1..].as_mut_ptr().write(b'l');
-    ///     buf.chunk_mut()[2..].as_mut_ptr().write(b'o');
-    ///
-    ///     buf.advance_mut(3);
-    /// }
-    ///
-    /// assert_eq!(5, buf.len());
-    /// assert_eq!(buf, b"hello");
-    /// ```
-    ///
-    /// # Implementer notes
-    ///
-    /// This function should never panic. `chunk_mut()` should return an empty
-    /// slice **if and only if** `remaining_mut()` returns 0. In other words,
-    /// `chunk_mut()` returning an empty slice implies that `remaining_mut()` will
-    /// return 0 and `remaining_mut()` returning 0 implies that `chunk_mut()` will
-    /// return an empty slice.
-    ///
-    /// This function may trigger an out-of-memory abort if it tries to allocate
-    /// memory and fails to do so.
-    // The `chunk_mut` method was previously called `bytes_mut`. This alias makes the
-    // rename more easily discoverable.
-    #[cfg_attr(docsrs, doc(alias = "bytes_mut"))]
-    fn chunk_mut(&mut self) -> &mut UninitSlice;
-
-    /// Transfer bytes into `self` from `src` and advance the cursor by the
-    /// number of bytes written.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    ///
-    /// buf.put_u8(b'h');
-    /// buf.put(&b"ello"[..]);
-    /// buf.put(&b" world"[..]);
-    ///
-    /// assert_eq!(buf, b"hello world");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if `self` does not have enough capacity to contain `src`.
-    #[inline]
-    fn put<T: super::Buf>(&mut self, mut src: T)
-    where
-        Self: Sized,
-    {
-        if self.remaining_mut() < src.remaining() {
-            panic_advance(&TryGetError {
-                requested: src.remaining(),
-                available: self.remaining_mut(),
-            });
-        }
-
-        while src.has_remaining() {
-            let s = src.chunk();
-            let d = self.chunk_mut();
-            let cnt = usize::min(s.len(), d.len());
-
-            d[..cnt].copy_from_slice(&s[..cnt]);
-
-            // SAFETY: We just initialized `cnt` bytes in `self`.
-            unsafe { self.advance_mut(cnt) };
-            src.advance(cnt);
-        }
-    }
-
-    /// Transfer bytes into `self` from `src` and advance the cursor by the
-    /// number of bytes written.
-    ///
-    /// `self` must have enough remaining capacity to contain all of `src`.
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut dst = [0; 6];
-    ///
-    /// {
-    ///     let mut buf = &mut dst[..];
-    ///     buf.put_slice(b"hello");
-    ///
-    ///     assert_eq!(1, buf.remaining_mut());
-    /// }
-    ///
-    /// assert_eq!(b"hello\0", &dst);
-    /// ```
-    #[inline]
-    fn put_slice(&mut self, mut src: &[u8]) {
-        if self.remaining_mut() < src.len() {
-            panic_advance(&TryGetError {
-                requested: src.len(),
-                available: self.remaining_mut(),
-            });
-        }
-
-        while !src.is_empty() {
-            let dst = self.chunk_mut();
-            let cnt = usize::min(src.len(), dst.len());
-
-            dst[..cnt].copy_from_slice(&src[..cnt]);
-            src = &src[cnt..];
-
-            // SAFETY: We just initialized `cnt` bytes in `self`.
-            unsafe { self.advance_mut(cnt) };
-        }
-    }
-
-    /// Put `cnt` bytes `val` into `self`.
-    ///
-    /// Logically equivalent to calling `self.put_u8(val)` `cnt` times, but may work faster.
-    ///
-    /// `self` must have at least `cnt` remaining capacity.
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut dst = [0; 6];
-    ///
-    /// {
-    ///     let mut buf = &mut dst[..];
-    ///     buf.put_bytes(b'a', 4);
-    ///
-    ///     assert_eq!(2, buf.remaining_mut());
-    /// }
-    ///
-    /// assert_eq!(b"aaaa\0\0", &dst);
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_bytes(&mut self, val: u8, mut cnt: usize) {
-        if self.remaining_mut() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.remaining_mut(),
-            })
-        }
-
-        while cnt > 0 {
-            let dst = self.chunk_mut();
-            let dst_len = usize::min(dst.len(), cnt);
-            // SAFETY: The pointer is valid for `dst_len <= dst.len()` bytes.
-            unsafe { core::ptr::write_bytes(dst.as_mut_ptr(), val, dst_len) };
-            // SAFETY: We just initialized `dst_len` bytes in `self`.
-            unsafe { self.advance_mut(dst_len) };
-            cnt -= dst_len;
-        }
-    }
-
-    /// Writes an unsigned 8 bit integer to `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u8(0x01);
-    /// assert_eq!(buf, b"\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u8(&mut self, n: u8) {
-        let src = [n];
-        self.put_slice(&src);
-    }
-
-    /// Writes a signed 8 bit integer to `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i8(0x01);
-    /// assert_eq!(buf, b"\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i8(&mut self, n: i8) {
-        let src = [n as u8];
-        self.put_slice(&src)
-    }
-
-    /// Writes an unsigned 16 bit integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u16(0x0809);
-    /// assert_eq!(buf, b"\x08\x09");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u16(&mut self, n: u16) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes an unsigned 16 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u16_le(0x0809);
-    /// assert_eq!(buf, b"\x09\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u16_le(&mut self, n: u16) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes an unsigned 16 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u16_ne(0x0809);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x08\x09");
-    /// } else {
-    ///     assert_eq!(buf, b"\x09\x08");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u16_ne(&mut self, n: u16) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes a signed 16 bit integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i16(0x0809);
-    /// assert_eq!(buf, b"\x08\x09");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i16(&mut self, n: i16) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes a signed 16 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i16_le(0x0809);
-    /// assert_eq!(buf, b"\x09\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i16_le(&mut self, n: i16) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes a signed 16 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i16_ne(0x0809);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x08\x09");
-    /// } else {
-    ///     assert_eq!(buf, b"\x09\x08");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i16_ne(&mut self, n: i16) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes an unsigned 32 bit integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u32(0x0809A0A1);
-    /// assert_eq!(buf, b"\x08\x09\xA0\xA1");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u32(&mut self, n: u32) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes an unsigned 32 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u32_le(0x0809A0A1);
-    /// assert_eq!(buf, b"\xA1\xA0\x09\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u32_le(&mut self, n: u32) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes an unsigned 32 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u32_ne(0x0809A0A1);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x08\x09\xA0\xA1");
-    /// } else {
-    ///     assert_eq!(buf, b"\xA1\xA0\x09\x08");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u32_ne(&mut self, n: u32) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes a signed 32 bit integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i32(0x0809A0A1);
-    /// assert_eq!(buf, b"\x08\x09\xA0\xA1");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i32(&mut self, n: i32) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes a signed 32 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i32_le(0x0809A0A1);
-    /// assert_eq!(buf, b"\xA1\xA0\x09\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i32_le(&mut self, n: i32) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes a signed 32 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i32_ne(0x0809A0A1);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x08\x09\xA0\xA1");
-    /// } else {
-    ///     assert_eq!(buf, b"\xA1\xA0\x09\x08");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i32_ne(&mut self, n: i32) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes an unsigned 64 bit integer to `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u64(0x0102030405060708);
-    /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u64(&mut self, n: u64) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes an unsigned 64 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u64_le(0x0102030405060708);
-    /// assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u64_le(&mut self, n: u64) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes an unsigned 64 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u64_ne(0x0102030405060708);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
-    /// } else {
-    ///     assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u64_ne(&mut self, n: u64) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes a signed 64 bit integer to `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i64(0x0102030405060708);
-    /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i64(&mut self, n: i64) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes a signed 64 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i64_le(0x0102030405060708);
-    /// assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i64_le(&mut self, n: i64) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes a signed 64 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i64_ne(0x0102030405060708);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
-    /// } else {
-    ///     assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i64_ne(&mut self, n: i64) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes an unsigned 128 bit integer to `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u128(0x01020304050607080910111213141516);
-    /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u128(&mut self, n: u128) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes an unsigned 128 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u128_le(0x01020304050607080910111213141516);
-    /// assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u128_le(&mut self, n: u128) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes an unsigned 128 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u128_ne(0x01020304050607080910111213141516);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
-    /// } else {
-    ///     assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u128_ne(&mut self, n: u128) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes a signed 128 bit integer to `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i128(0x01020304050607080910111213141516);
-    /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i128(&mut self, n: i128) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes a signed 128 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i128_le(0x01020304050607080910111213141516);
-    /// assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i128_le(&mut self, n: i128) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes a signed 128 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i128_ne(0x01020304050607080910111213141516);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
-    /// } else {
-    ///     assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i128_ne(&mut self, n: i128) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes an unsigned n-byte integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_uint(0x010203, 3);
-    /// assert_eq!(buf, b"\x01\x02\x03");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_uint(&mut self, n: u64, nbytes: usize) {
-        let start = match mem::size_of_val(&n).checked_sub(nbytes) {
-            Some(start) => start,
-            None => panic_does_not_fit(nbytes, mem::size_of_val(&n)),
-        };
-
-        self.put_slice(&n.to_be_bytes()[start..]);
-    }
-
-    /// Writes an unsigned n-byte integer to `self` in the little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_uint_le(0x010203, 3);
-    /// assert_eq!(buf, b"\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_uint_le(&mut self, n: u64, nbytes: usize) {
-        let slice = n.to_le_bytes();
-        let slice = match slice.get(..nbytes) {
-            Some(slice) => slice,
-            None => panic_does_not_fit(nbytes, slice.len()),
-        };
-
-        self.put_slice(slice);
-    }
-
-    /// Writes an unsigned n-byte integer to `self` in the native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_uint_ne(0x010203, 3);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03");
-    /// } else {
-    ///     assert_eq!(buf, b"\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_uint_ne(&mut self, n: u64, nbytes: usize) {
-        if cfg!(target_endian = "big") {
-            self.put_uint(n, nbytes)
-        } else {
-            self.put_uint_le(n, nbytes)
-        }
-    }
-
-    /// Writes low `nbytes` of a signed integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_int(0x0504010203, 3);
-    /// assert_eq!(buf, b"\x01\x02\x03");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_int(&mut self, n: i64, nbytes: usize) {
-        let start = match mem::size_of_val(&n).checked_sub(nbytes) {
-            Some(start) => start,
-            None => panic_does_not_fit(nbytes, mem::size_of_val(&n)),
-        };
-
-        self.put_slice(&n.to_be_bytes()[start..]);
-    }
-
-    /// Writes low `nbytes` of a signed integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_int_le(0x0504010203, 3);
-    /// assert_eq!(buf, b"\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_int_le(&mut self, n: i64, nbytes: usize) {
-        let slice = n.to_le_bytes();
-        let slice = match slice.get(..nbytes) {
-            Some(slice) => slice,
-            None => panic_does_not_fit(nbytes, slice.len()),
-        };
-
-        self.put_slice(slice);
-    }
-
-    /// Writes low `nbytes` of a signed integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_int_ne(0x010203, 3);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03");
-    /// } else {
-    ///     assert_eq!(buf, b"\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_int_ne(&mut self, n: i64, nbytes: usize) {
-        if cfg!(target_endian = "big") {
-            self.put_int(n, nbytes)
-        } else {
-            self.put_int_le(n, nbytes)
-        }
-    }
-
-    /// Writes an IEEE754 single-precision (4 bytes) floating point number to
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f32(1.2f32);
-    /// assert_eq!(buf, b"\x3F\x99\x99\x9A");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f32(&mut self, n: f32) {
-        self.put_u32(n.to_bits());
-    }
-
-    /// Writes an IEEE754 single-precision (4 bytes) floating point number to
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f32_le(1.2f32);
-    /// assert_eq!(buf, b"\x9A\x99\x99\x3F");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f32_le(&mut self, n: f32) {
-        self.put_u32_le(n.to_bits());
-    }
-
-    /// Writes an IEEE754 single-precision (4 bytes) floating point number to
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f32_ne(1.2f32);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x3F\x99\x99\x9A");
-    /// } else {
-    ///     assert_eq!(buf, b"\x9A\x99\x99\x3F");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f32_ne(&mut self, n: f32) {
-        self.put_u32_ne(n.to_bits());
-    }
-
-    /// Writes an IEEE754 double-precision (8 bytes) floating point number to
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f64(1.2f64);
-    /// assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f64(&mut self, n: f64) {
-        self.put_u64(n.to_bits());
-    }
-
-    /// Writes an IEEE754 double-precision (8 bytes) floating point number to
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f64_le(1.2f64);
-    /// assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f64_le(&mut self, n: f64) {
-        self.put_u64_le(n.to_bits());
-    }
-
-    /// Writes an IEEE754 double-precision (8 bytes) floating point number to
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f64_ne(1.2f64);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33");
-    /// } else {
-    ///     assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f64_ne(&mut self, n: f64) {
-        self.put_u64_ne(n.to_bits());
-    }
-
-    /// Creates an adaptor which can write at most `limit` bytes to `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let arr = &mut [0u8; 128][..];
-    /// assert_eq!(arr.remaining_mut(), 128);
-    ///
-    /// let dst = arr.limit(10);
-    /// assert_eq!(dst.remaining_mut(), 10);
-    /// ```
-    #[inline]
-    fn limit(self, limit: usize) -> Limit<Self>
-    where
-        Self: Sized,
-    {
-        limit::new(self, limit)
-    }
-
-    /// Creates an adaptor which implements the `Write` trait for `self`.
-    ///
-    /// This function returns a new value which implements `Write` by adapting
-    /// the `Write` trait functions to the `BufMut` trait functions. Given that
-    /// `BufMut` operations are infallible, none of the `Write` functions will
-    /// return with `Err`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    /// use std::io::Write;
-    ///
-    /// let mut buf = vec![].writer();
-    ///
-    /// let num = buf.write(&b"hello world"[..]).unwrap();
-    /// assert_eq!(11, num);
-    ///
-    /// let buf = buf.into_inner();
-    ///
-    /// assert_eq!(*buf, b"hello world"[..]);
-    /// ```
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-    #[inline]
-    fn writer(self) -> Writer<Self>
-    where
-        Self: Sized,
-    {
-        writer::new(self)
-    }
-
-    /// Creates an adapter which will chain this buffer with another.
-    ///
-    /// The returned `BufMut` instance will first write to all bytes from
-    /// `self`. Afterwards, it will write to `next`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut a = [0u8; 5];
-    /// let mut b = [0u8; 6];
-    ///
-    /// let mut chain = (&mut a[..]).chain_mut(&mut b[..]);
-    ///
-    /// chain.put_slice(b"hello world");
-    ///
-    /// assert_eq!(&a[..], b"hello");
-    /// assert_eq!(&b[..], b" world");
-    /// ```
-    #[inline]
-    fn chain_mut<U: BufMut>(self, next: U) -> Chain<Self, U>
-    where
-        Self: Sized,
-    {
-        Chain::new(self, next)
-    }
-}
-
-macro_rules! deref_forward_bufmut {
-    () => {
-        #[inline]
-        fn remaining_mut(&self) -> usize {
-            (**self).remaining_mut()
-        }
-
-        #[inline]
-        fn chunk_mut(&mut self) -> &mut UninitSlice {
-            (**self).chunk_mut()
-        }
-
-        #[inline]
-        unsafe fn advance_mut(&mut self, cnt: usize) {
-            (**self).advance_mut(cnt)
-        }
-
-        #[inline]
-        fn put_slice(&mut self, src: &[u8]) {
-            (**self).put_slice(src)
-        }
-
-        #[inline]
-        fn put_u8(&mut self, n: u8) {
-            (**self).put_u8(n)
-        }
-
-        #[inline]
-        fn put_i8(&mut self, n: i8) {
-            (**self).put_i8(n)
-        }
-
-        #[inline]
-        fn put_u16(&mut self, n: u16) {
-            (**self).put_u16(n)
-        }
-
-        #[inline]
-        fn put_u16_le(&mut self, n: u16) {
-            (**self).put_u16_le(n)
-        }
-
-        #[inline]
-        fn put_u16_ne(&mut self, n: u16) {
-            (**self).put_u16_ne(n)
-        }
-
-        #[inline]
-        fn put_i16(&mut self, n: i16) {
-            (**self).put_i16(n)
-        }
-
-        #[inline]
-        fn put_i16_le(&mut self, n: i16) {
-            (**self).put_i16_le(n)
-        }
-
-        #[inline]
-        fn put_i16_ne(&mut self, n: i16) {
-            (**self).put_i16_ne(n)
-        }
-
-        #[inline]
-        fn put_u32(&mut self, n: u32) {
-            (**self).put_u32(n)
-        }
-
-        #[inline]
-        fn put_u32_le(&mut self, n: u32) {
-            (**self).put_u32_le(n)
-        }
-
-        #[inline]
-        fn put_u32_ne(&mut self, n: u32) {
-            (**self).put_u32_ne(n)
-        }
-
-        #[inline]
-        fn put_i32(&mut self, n: i32) {
-            (**self).put_i32(n)
-        }
-
-        #[inline]
-        fn put_i32_le(&mut self, n: i32) {
-            (**self).put_i32_le(n)
-        }
-
-        #[inline]
-        fn put_i32_ne(&mut self, n: i32) {
-            (**self).put_i32_ne(n)
-        }
-
-        #[inline]
-        fn put_u64(&mut self, n: u64) {
-            (**self).put_u64(n)
-        }
-
-        #[inline]
-        fn put_u64_le(&mut self, n: u64) {
-            (**self).put_u64_le(n)
-        }
-
-        #[inline]
-        fn put_u64_ne(&mut self, n: u64) {
-            (**self).put_u64_ne(n)
-        }
-
-        #[inline]
-        fn put_i64(&mut self, n: i64) {
-            (**self).put_i64(n)
-        }
-
-        #[inline]
-        fn put_i64_le(&mut self, n: i64) {
-            (**self).put_i64_le(n)
-        }
-
-        #[inline]
-        fn put_i64_ne(&mut self, n: i64) {
-            (**self).put_i64_ne(n)
-        }
-    };
-}
-
-unsafe impl<T: BufMut + ?Sized> BufMut for &mut T {
-    deref_forward_bufmut!();
-}
-
-unsafe impl<T: BufMut + ?Sized> BufMut for Box<T> {
-    deref_forward_bufmut!();
-}
-
-unsafe impl BufMut for &mut [u8] {
-    #[inline]
-    fn remaining_mut(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        UninitSlice::new(self)
-    }
-
-    #[inline]
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        // Lifetime dance taken from `impl Write for &mut [u8]`.
-        let (_, b) = core::mem::replace(self, &mut []).split_at_mut(cnt);
-        *self = b;
-    }
-
-    #[inline]
-    fn put_slice(&mut self, src: &[u8]) {
-        if self.len() < src.len() {
-            panic_advance(&TryGetError {
-                requested: src.len(),
-                available: self.len(),
-            });
-        }
-
-        self[..src.len()].copy_from_slice(src);
-        // SAFETY: We just initialized `src.len()` bytes.
-        unsafe { self.advance_mut(src.len()) };
-    }
-
-    #[inline]
-    fn put_bytes(&mut self, val: u8, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        // SAFETY: We just checked that the pointer is valid for `cnt` bytes.
-        unsafe {
-            ptr::write_bytes(self.as_mut_ptr(), val, cnt);
-            self.advance_mut(cnt);
-        }
-    }
-}
-
-unsafe impl BufMut for &mut [core::mem::MaybeUninit<u8>] {
-    #[inline]
-    fn remaining_mut(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        UninitSlice::uninit(self)
-    }
-
-    #[inline]
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        // Lifetime dance taken from `impl Write for &mut [u8]`.
-        let (_, b) = core::mem::replace(self, &mut []).split_at_mut(cnt);
-        *self = b;
-    }
-
-    #[inline]
-    fn put_slice(&mut self, src: &[u8]) {
-        if self.len() < src.len() {
-            panic_advance(&TryGetError {
-                requested: src.len(),
-                available: self.len(),
-            });
-        }
-
-        // SAFETY: We just checked that the pointer is valid for `src.len()` bytes.
-        unsafe {
-            ptr::copy_nonoverlapping(src.as_ptr(), self.as_mut_ptr().cast(), src.len());
-            self.advance_mut(src.len());
-        }
-    }
-
-    #[inline]
-    fn put_bytes(&mut self, val: u8, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        // SAFETY: We just checked that the pointer is valid for `cnt` bytes.
-        unsafe {
-            ptr::write_bytes(self.as_mut_ptr() as *mut u8, val, cnt);
-            self.advance_mut(cnt);
-        }
-    }
-}
-
-unsafe impl BufMut for Vec<u8> {
-    #[inline]
-    fn remaining_mut(&self) -> usize {
-        // A vector can never have more than isize::MAX bytes
-        core::isize::MAX as usize - self.len()
-    }
-
-    #[inline]
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        let len = self.len();
-        let remaining = self.capacity() - len;
-
-        if remaining < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: remaining,
-            });
-        }
-
-        // Addition will not overflow since the sum is at most the capacity.
-        self.set_len(len + cnt);
-    }
-
-    #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        if self.capacity() == self.len() {
-            self.reserve(64); // Grow the vec
-        }
-
-        let cap = self.capacity();
-        let len = self.len();
-
-        let ptr = self.as_mut_ptr();
-        // SAFETY: Since `ptr` is valid for `cap` bytes, `ptr.add(len)` must be
-        // valid for `cap - len` bytes. The subtraction will not underflow since
-        // `len <= cap`.
-        unsafe { UninitSlice::from_raw_parts_mut(ptr.add(len), cap - len) }
-    }
-
-    // Specialize these methods so they can skip checking `remaining_mut`
-    // and `advance_mut`.
-    #[inline]
-    fn put<T: super::Buf>(&mut self, mut src: T)
-    where
-        Self: Sized,
-    {
-        // In case the src isn't contiguous, reserve upfront.
-        self.reserve(src.remaining());
-
-        while src.has_remaining() {
-            let s = src.chunk();
-            let l = s.len();
-            self.extend_from_slice(s);
-            src.advance(l);
-        }
-    }
-
-    #[inline]
-    fn put_slice(&mut self, src: &[u8]) {
-        self.extend_from_slice(src);
-    }
-
-    #[inline]
-    fn put_bytes(&mut self, val: u8, cnt: usize) {
-        // If the addition overflows, then the `resize` will fail.
-        let new_len = self.len().saturating_add(cnt);
-        self.resize(new_len, val);
-    }
-}
-
-// The existence of this function makes the compiler catch if the BufMut
-// trait is "object-safe" or not.
-fn _assert_trait_object(_b: &dyn BufMut) {}
diff --git a/vendor/bytes/src/buf/chain.rs b/vendor/bytes/src/buf/chain.rs
deleted file mode 100644
index c8bc36de..00000000
--- a/vendor/bytes/src/buf/chain.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-use crate::buf::{IntoIter, UninitSlice};
-use crate::{Buf, BufMut};
-
-#[cfg(feature = "std")]
-use std::io::IoSlice;
-
-/// A `Chain` sequences two buffers.
-///
-/// `Chain` is an adapter that links two underlying buffers and provides a
-/// continuous view across both buffers. It is able to sequence either immutable
-/// buffers ([`Buf`] values) or mutable buffers ([`BufMut`] values).
-///
-/// This struct is generally created by calling [`Buf::chain`]. Please see that
-/// function's documentation for more detail.
-///
-/// # Examples
-///
-/// ```
-/// use bytes::{Bytes, Buf};
-///
-/// let mut buf = (&b"hello "[..])
-///     .chain(&b"world"[..]);
-///
-/// let full: Bytes = buf.copy_to_bytes(11);
-/// assert_eq!(full[..], b"hello world"[..]);
-/// ```
-///
-/// [`Buf::chain`]: Buf::chain
-#[derive(Debug)]
-pub struct Chain<T, U> {
-    a: T,
-    b: U,
-}
-
-impl<T, U> Chain<T, U> {
-    /// Creates a new `Chain` sequencing the provided values.
-    pub(crate) fn new(a: T, b: U) -> Chain<T, U> {
-        Chain { a, b }
-    }
-
-    /// Gets a reference to the first underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let buf = (&b"hello"[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// assert_eq!(buf.first_ref()[..], b"hello"[..]);
-    /// ```
-    pub fn first_ref(&self) -> &T {
-        &self.a
-    }
-
-    /// Gets a mutable reference to the first underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = (&b"hello"[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// buf.first_mut().advance(1);
-    ///
-    /// let full = buf.copy_to_bytes(9);
-    /// assert_eq!(full, b"elloworld"[..]);
-    /// ```
-    pub fn first_mut(&mut self) -> &mut T {
-        &mut self.a
-    }
-
-    /// Gets a reference to the last underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let buf = (&b"hello"[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// assert_eq!(buf.last_ref()[..], b"world"[..]);
-    /// ```
-    pub fn last_ref(&self) -> &U {
-        &self.b
-    }
-
-    /// Gets a mutable reference to the last underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = (&b"hello "[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// buf.last_mut().advance(1);
-    ///
-    /// let full = buf.copy_to_bytes(10);
-    /// assert_eq!(full, b"hello orld"[..]);
-    /// ```
-    pub fn last_mut(&mut self) -> &mut U {
-        &mut self.b
-    }
-
-    /// Consumes this `Chain`, returning the underlying values.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let chain = (&b"hello"[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// let (first, last) = chain.into_inner();
-    /// assert_eq!(first[..], b"hello"[..]);
-    /// assert_eq!(last[..], b"world"[..]);
-    /// ```
-    pub fn into_inner(self) -> (T, U) {
-        (self.a, self.b)
-    }
-}
-
-impl<T, U> Buf for Chain<T, U>
-where
-    T: Buf,
-    U: Buf,
-{
-    fn remaining(&self) -> usize {
-        self.a.remaining().saturating_add(self.b.remaining())
-    }
-
-    fn chunk(&self) -> &[u8] {
-        if self.a.has_remaining() {
-            self.a.chunk()
-        } else {
-            self.b.chunk()
-        }
-    }
-
-    fn advance(&mut self, mut cnt: usize) {
-        let a_rem = self.a.remaining();
-
-        if a_rem != 0 {
-            if a_rem >= cnt {
-                self.a.advance(cnt);
-                return;
-            }
-
-            // Consume what is left of a
-            self.a.advance(a_rem);
-
-            cnt -= a_rem;
-        }
-
-        self.b.advance(cnt);
-    }
-
-    #[cfg(feature = "std")]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
-        let mut n = self.a.chunks_vectored(dst);
-        n += self.b.chunks_vectored(&mut dst[n..]);
-        n
-    }
-
-    fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
-        let a_rem = self.a.remaining();
-        if a_rem >= len {
-            self.a.copy_to_bytes(len)
-        } else if a_rem == 0 {
-            self.b.copy_to_bytes(len)
-        } else {
-            assert!(
-                len - a_rem <= self.b.remaining(),
-                "`len` greater than remaining"
-            );
-            let mut ret = crate::BytesMut::with_capacity(len);
-            ret.put(&mut self.a);
-            ret.put((&mut self.b).take(len - a_rem));
-            ret.freeze()
-        }
-    }
-}
-
-unsafe impl<T, U> BufMut for Chain<T, U>
-where
-    T: BufMut,
-    U: BufMut,
-{
-    fn remaining_mut(&self) -> usize {
-        self.a
-            .remaining_mut()
-            .saturating_add(self.b.remaining_mut())
-    }
-
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        if self.a.has_remaining_mut() {
-            self.a.chunk_mut()
-        } else {
-            self.b.chunk_mut()
-        }
-    }
-
-    unsafe fn advance_mut(&mut self, mut cnt: usize) {
-        let a_rem = self.a.remaining_mut();
-
-        if a_rem != 0 {
-            if a_rem >= cnt {
-                self.a.advance_mut(cnt);
-                return;
-            }
-
-            // Consume what is left of a
-            self.a.advance_mut(a_rem);
-
-            cnt -= a_rem;
-        }
-
-        self.b.advance_mut(cnt);
-    }
-}
-
-impl<T, U> IntoIterator for Chain<T, U>
-where
-    T: Buf,
-    U: Buf,
-{
-    type Item = u8;
-    type IntoIter = IntoIter<Chain<T, U>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter::new(self)
-    }
-}
diff --git a/vendor/bytes/src/buf/iter.rs b/vendor/bytes/src/buf/iter.rs
deleted file mode 100644
index 74f9b991..00000000
--- a/vendor/bytes/src/buf/iter.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-use crate::Buf;
-
-/// Iterator over the bytes contained by the buffer.
-///
-/// # Examples
-///
-/// Basic usage:
-///
-/// ```
-/// use bytes::Bytes;
-///
-/// let buf = Bytes::from(&b"abc"[..]);
-/// let mut iter = buf.into_iter();
-///
-/// assert_eq!(iter.next(), Some(b'a'));
-/// assert_eq!(iter.next(), Some(b'b'));
-/// assert_eq!(iter.next(), Some(b'c'));
-/// assert_eq!(iter.next(), None);
-/// ```
-#[derive(Debug)]
-pub struct IntoIter<T> {
-    inner: T,
-}
-
-impl<T> IntoIter<T> {
-    /// Creates an iterator over the bytes contained by the buffer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let buf = Bytes::from_static(b"abc");
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    /// assert_eq!(iter.next(), Some(b'b'));
-    /// assert_eq!(iter.next(), Some(b'c'));
-    /// assert_eq!(iter.next(), None);
-    /// ```
-    pub fn new(inner: T) -> IntoIter<T> {
-        IntoIter { inner }
-    }
-
-    /// Consumes this `IntoIter`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, Bytes};
-    ///
-    /// let buf = Bytes::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// let buf = iter.into_inner();
-    /// assert_eq!(2, buf.remaining());
-    /// ```
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    /// Gets a reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, Bytes};
-    ///
-    /// let buf = Bytes::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// assert_eq!(2, iter.get_ref().remaining());
-    /// ```
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BytesMut};
-    ///
-    /// let buf = BytesMut::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// iter.get_mut().advance(1);
-    ///
-    /// assert_eq!(iter.next(), Some(b'c'));
-    /// ```
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-}
-
-impl<T: Buf> Iterator for IntoIter<T> {
-    type Item = u8;
-
-    fn next(&mut self) -> Option<u8> {
-        if !self.inner.has_remaining() {
-            return None;
-        }
-
-        let b = self.inner.chunk()[0];
-        self.inner.advance(1);
-
-        Some(b)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let rem = self.inner.remaining();
-        (rem, Some(rem))
-    }
-}
-
-impl<T: Buf> ExactSizeIterator for IntoIter<T> {}
diff --git a/vendor/bytes/src/buf/limit.rs b/vendor/bytes/src/buf/limit.rs
deleted file mode 100644
index b422be53..00000000
--- a/vendor/bytes/src/buf/limit.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use crate::buf::UninitSlice;
-use crate::BufMut;
-
-use core::cmp;
-
-/// A `BufMut` adapter which limits the amount of bytes that can be written
-/// to an underlying buffer.
-#[derive(Debug)]
-pub struct Limit<T> {
-    inner: T,
-    limit: usize,
-}
-
-pub(super) fn new<T>(inner: T, limit: usize) -> Limit<T> {
-    Limit { inner, limit }
-}
-
-impl<T> Limit<T> {
-    /// Consumes this `Limit`, returning the underlying value.
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    /// Gets a reference to the underlying `BufMut`.
-    ///
-    /// It is inadvisable to directly write to the underlying `BufMut`.
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying `BufMut`.
-    ///
-    /// It is inadvisable to directly write to the underlying `BufMut`.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-
-    /// Returns the maximum number of bytes that can be written
-    ///
-    /// # Note
-    ///
-    /// If the inner `BufMut` has fewer bytes than indicated by this method then
-    /// that is the actual number of available bytes.
-    pub fn limit(&self) -> usize {
-        self.limit
-    }
-
-    /// Sets the maximum number of bytes that can be written.
-    ///
-    /// # Note
-    ///
-    /// If the inner `BufMut` has fewer bytes than `lim` then that is the actual
-    /// number of available bytes.
-    pub fn set_limit(&mut self, lim: usize) {
-        self.limit = lim
-    }
-}
-
-unsafe impl<T: BufMut> BufMut for Limit<T> {
-    fn remaining_mut(&self) -> usize {
-        cmp::min(self.inner.remaining_mut(), self.limit)
-    }
-
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        let bytes = self.inner.chunk_mut();
-        let end = cmp::min(bytes.len(), self.limit);
-        &mut bytes[..end]
-    }
-
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        assert!(cnt <= self.limit);
-        self.inner.advance_mut(cnt);
-        self.limit -= cnt;
-    }
-}
diff --git a/vendor/bytes/src/buf/mod.rs b/vendor/bytes/src/buf/mod.rs
deleted file mode 100644
index 1bf0a47e..00000000
--- a/vendor/bytes/src/buf/mod.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Utilities for working with buffers.
-//!
-//! A buffer is any structure that contains a sequence of bytes. The bytes may
-//! or may not be stored in contiguous memory. This module contains traits used
-//! to abstract over buffers as well as utilities for working with buffer types.
-//!
-//! # `Buf`, `BufMut`
-//!
-//! These are the two foundational traits for abstractly working with buffers.
-//! They can be thought as iterators for byte structures. They offer additional
-//! performance over `Iterator` by providing an API optimized for byte slices.
-//!
-//! See [`Buf`] and [`BufMut`] for more details.
-//!
-//! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure)
-
-mod buf_impl;
-mod buf_mut;
-mod chain;
-mod iter;
-mod limit;
-#[cfg(feature = "std")]
-mod reader;
-mod take;
-mod uninit_slice;
-mod vec_deque;
-#[cfg(feature = "std")]
-mod writer;
-
-pub use self::buf_impl::Buf;
-pub use self::buf_mut::BufMut;
-pub use self::chain::Chain;
-pub use self::iter::IntoIter;
-pub use self::limit::Limit;
-pub use self::take::Take;
-pub use self::uninit_slice::UninitSlice;
-
-#[cfg(feature = "std")]
-pub use self::{reader::Reader, writer::Writer};
diff --git a/vendor/bytes/src/buf/reader.rs b/vendor/bytes/src/buf/reader.rs
deleted file mode 100644
index 52149495..00000000
--- a/vendor/bytes/src/buf/reader.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use crate::Buf;
-
-use std::{cmp, io};
-
-/// A `Buf` adapter which implements `io::Read` for the inner value.
-///
-/// This struct is generally created by calling `reader()` on `Buf`. See
-/// documentation of [`reader()`](Buf::reader) for more
-/// details.
-#[derive(Debug)]
-pub struct Reader<B> {
-    buf: B,
-}
-
-pub fn new<B>(buf: B) -> Reader<B> {
-    Reader { buf }
-}
-
-impl<B: Buf> Reader<B> {
-    /// Gets a reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::Buf;
-    ///
-    /// let buf = b"hello world".reader();
-    ///
-    /// assert_eq!(b"hello world", buf.get_ref());
-    /// ```
-    pub fn get_ref(&self) -> &B {
-        &self.buf
-    }
-
-    /// Gets a mutable reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    pub fn get_mut(&mut self) -> &mut B {
-        &mut self.buf
-    }
-
-    /// Consumes this `Reader`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::Buf;
-    /// use std::io;
-    ///
-    /// let mut buf = b"hello world".reader();
-    /// let mut dst = vec![];
-    ///
-    /// io::copy(&mut buf, &mut dst).unwrap();
-    ///
-    /// let buf = buf.into_inner();
-    /// assert_eq!(0, buf.remaining());
-    /// ```
-    pub fn into_inner(self) -> B {
-        self.buf
-    }
-}
-
-impl<B: Buf + Sized> io::Read for Reader<B> {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        let len = cmp::min(self.buf.remaining(), dst.len());
-
-        Buf::copy_to_slice(&mut self.buf, &mut dst[0..len]);
-        Ok(len)
-    }
-}
-
-impl<B: Buf + Sized> io::BufRead for Reader<B> {
-    fn fill_buf(&mut self) -> io::Result<&[u8]> {
-        Ok(self.buf.chunk())
-    }
-    fn consume(&mut self, amt: usize) {
-        self.buf.advance(amt)
-    }
-}
diff --git a/vendor/bytes/src/buf/take.rs b/vendor/bytes/src/buf/take.rs
deleted file mode 100644
index acfeef6e..00000000
--- a/vendor/bytes/src/buf/take.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-use crate::Buf;
-
-use core::cmp;
-
-#[cfg(feature = "std")]
-use std::io::IoSlice;
-
-/// A `Buf` adapter which limits the bytes read from an underlying buffer.
-///
-/// This struct is generally created by calling `take()` on `Buf`. See
-/// documentation of [`take()`](Buf::take) for more details.
-#[derive(Debug)]
-pub struct Take<T> {
-    inner: T,
-    limit: usize,
-}
-
-pub fn new<T>(inner: T, limit: usize) -> Take<T> {
-    Take { inner, limit }
-}
-
-impl<T> Take<T> {
-    /// Consumes this `Take`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BufMut};
-    ///
-    /// let mut buf = b"hello world".take(2);
-    /// let mut dst = vec![];
-    ///
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"he"[..]);
-    ///
-    /// let mut buf = buf.into_inner();
-    ///
-    /// dst.clear();
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"llo world"[..]);
-    /// ```
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    /// Gets a reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::Buf;
-    ///
-    /// let buf = b"hello world".take(2);
-    ///
-    /// assert_eq!(11, buf.get_ref().remaining());
-    /// ```
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BufMut};
-    ///
-    /// let mut buf = b"hello world".take(2);
-    /// let mut dst = vec![];
-    ///
-    /// buf.get_mut().advance(2);
-    ///
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"ll"[..]);
-    /// ```
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-
-    /// Returns the maximum number of bytes that can be read.
-    ///
-    /// # Note
-    ///
-    /// If the inner `Buf` has fewer bytes than indicated by this method then
-    /// that is the actual number of available bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = b"hello world".take(2);
-    ///
-    /// assert_eq!(2, buf.limit());
-    /// assert_eq!(b'h', buf.get_u8());
-    /// assert_eq!(1, buf.limit());
-    /// ```
-    pub fn limit(&self) -> usize {
-        self.limit
-    }
-
-    /// Sets the maximum number of bytes that can be read.
-    ///
-    /// # Note
-    ///
-    /// If the inner `Buf` has fewer bytes than `lim` then that is the actual
-    /// number of available bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BufMut};
-    ///
-    /// let mut buf = b"hello world".take(2);
-    /// let mut dst = vec![];
-    ///
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"he"[..]);
-    ///
-    /// dst.clear();
-    ///
-    /// buf.set_limit(3);
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"llo"[..]);
-    /// ```
-    pub fn set_limit(&mut self, lim: usize) {
-        self.limit = lim
-    }
-}
-
-impl<T: Buf> Buf for Take<T> {
-    fn remaining(&self) -> usize {
-        cmp::min(self.inner.remaining(), self.limit)
-    }
-
-    fn chunk(&self) -> &[u8] {
-        let bytes = self.inner.chunk();
-        &bytes[..cmp::min(bytes.len(), self.limit)]
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        assert!(cnt <= self.limit);
-        self.inner.advance(cnt);
-        self.limit -= cnt;
-    }
-
-    fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
-        assert!(len <= self.remaining(), "`len` greater than remaining");
-
-        let r = self.inner.copy_to_bytes(len);
-        self.limit -= len;
-        r
-    }
-
-    #[cfg(feature = "std")]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
-        if self.limit == 0 {
-            return 0;
-        }
-
-        const LEN: usize = 16;
-        let mut slices: [IoSlice<'a>; LEN] = [
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-        ];
-
-        let cnt = self
-            .inner
-            .chunks_vectored(&mut slices[..dst.len().min(LEN)]);
-        let mut limit = self.limit;
-        for (i, (dst, slice)) in dst[..cnt].iter_mut().zip(slices.iter()).enumerate() {
-            if let Some(buf) = slice.get(..limit) {
-                // SAFETY: We could do this safely with `IoSlice::advance` if we had a larger MSRV.
-                let buf = unsafe { std::mem::transmute::<&[u8], &'a [u8]>(buf) };
-                *dst = IoSlice::new(buf);
-                return i + 1;
-            } else {
-                // SAFETY: We could do this safely with `IoSlice::advance` if we had a larger MSRV.
-                let buf = unsafe { std::mem::transmute::<&[u8], &'a [u8]>(slice) };
-                *dst = IoSlice::new(buf);
-                limit -= slice.len();
-            }
-        }
-        cnt
-    }
-}
diff --git a/vendor/bytes/src/buf/uninit_slice.rs b/vendor/bytes/src/buf/uninit_slice.rs
deleted file mode 100644
index aea096ae..00000000
--- a/vendor/bytes/src/buf/uninit_slice.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-use core::fmt;
-use core::mem::MaybeUninit;
-use core::ops::{
-    Index, IndexMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
-};
-
-/// Uninitialized byte slice.
-///
-/// Returned by `BufMut::chunk_mut()`, the referenced byte slice may be
-/// uninitialized. The wrapper provides safe access without introducing
-/// undefined behavior.
-///
-/// The safety invariants of this wrapper are:
-///
-///  1. Reading from an `UninitSlice` is undefined behavior.
-///  2. Writing uninitialized bytes to an `UninitSlice` is undefined behavior.
-///
-/// The difference between `&mut UninitSlice` and `&mut [MaybeUninit<u8>]` is
-/// that it is possible in safe code to write uninitialized bytes to an
-/// `&mut [MaybeUninit<u8>]`, which this type prohibits.
-#[repr(transparent)]
-pub struct UninitSlice([MaybeUninit<u8>]);
-
-impl UninitSlice {
-    /// Creates a `&mut UninitSlice` wrapping a slice of initialised memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let mut buffer = [0u8; 64];
-    /// let slice = UninitSlice::new(&mut buffer[..]);
-    /// ```
-    #[inline]
-    pub fn new(slice: &mut [u8]) -> &mut UninitSlice {
-        unsafe { &mut *(slice as *mut [u8] as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
-    }
-
-    /// Creates a `&mut UninitSlice` wrapping a slice of uninitialised memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    /// use core::mem::MaybeUninit;
-    ///
-    /// let mut buffer = [MaybeUninit::uninit(); 64];
-    /// let slice = UninitSlice::uninit(&mut buffer[..]);
-    ///
-    /// let mut vec = Vec::with_capacity(1024);
-    /// let spare: &mut UninitSlice = vec.spare_capacity_mut().into();
-    /// ```
-    #[inline]
-    pub fn uninit(slice: &mut [MaybeUninit<u8>]) -> &mut UninitSlice {
-        unsafe { &mut *(slice as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
-    }
-
-    fn uninit_ref(slice: &[MaybeUninit<u8>]) -> &UninitSlice {
-        unsafe { &*(slice as *const [MaybeUninit<u8>] as *const UninitSlice) }
-    }
-
-    /// Create a `&mut UninitSlice` from a pointer and a length.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `ptr` references a valid memory region owned
-    /// by the caller representing a byte slice for the duration of `'a`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let bytes = b"hello world".to_vec();
-    /// let ptr = bytes.as_ptr() as *mut _;
-    /// let len = bytes.len();
-    ///
-    /// let slice = unsafe { UninitSlice::from_raw_parts_mut(ptr, len) };
-    /// ```
-    #[inline]
-    pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a mut UninitSlice {
-        let maybe_init: &mut [MaybeUninit<u8>] =
-            core::slice::from_raw_parts_mut(ptr as *mut _, len);
-        Self::uninit(maybe_init)
-    }
-
-    /// Write a single byte at the specified offset.
-    ///
-    /// # Panics
-    ///
-    /// The function panics if `index` is out of bounds.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let mut data = [b'f', b'o', b'o'];
-    /// let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) };
-    ///
-    /// slice.write_byte(0, b'b');
-    ///
-    /// assert_eq!(b"boo", &data[..]);
-    /// ```
-    #[inline]
-    pub fn write_byte(&mut self, index: usize, byte: u8) {
-        assert!(index < self.len());
-
-        unsafe { self[index..].as_mut_ptr().write(byte) }
-    }
-
-    /// Copies bytes from `src` into `self`.
-    ///
-    /// The length of `src` must be the same as `self`.
-    ///
-    /// # Panics
-    ///
-    /// The function panics if `src` has a different length than `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let mut data = [b'f', b'o', b'o'];
-    /// let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) };
-    ///
-    /// slice.copy_from_slice(b"bar");
-    ///
-    /// assert_eq!(b"bar", &data[..]);
-    /// ```
-    #[inline]
-    pub fn copy_from_slice(&mut self, src: &[u8]) {
-        use core::ptr;
-
-        assert_eq!(self.len(), src.len());
-
-        unsafe {
-            ptr::copy_nonoverlapping(src.as_ptr(), self.as_mut_ptr(), self.len());
-        }
-    }
-
-    /// Return a raw pointer to the slice's buffer.
-    ///
-    /// # Safety
-    ///
-    /// The caller **must not** read from the referenced memory and **must not**
-    /// write **uninitialized** bytes to the slice either.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut data = [0, 1, 2];
-    /// let mut slice = &mut data[..];
-    /// let ptr = BufMut::chunk_mut(&mut slice).as_mut_ptr();
-    /// ```
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut u8 {
-        self.0.as_mut_ptr() as *mut _
-    }
-
-    /// Return a `&mut [MaybeUninit<u8>]` to this slice's buffer.
-    ///
-    /// # Safety
-    ///
-    /// The caller **must not** read from the referenced memory and **must not** write
-    /// **uninitialized** bytes to the slice either. This is because `BufMut` implementation
-    /// that created the `UninitSlice` knows which parts are initialized. Writing uninitialized
-    /// bytes to the slice may cause the `BufMut` to read those bytes and trigger undefined
-    /// behavior.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut data = [0, 1, 2];
-    /// let mut slice = &mut data[..];
-    /// unsafe {
-    ///     let uninit_slice = BufMut::chunk_mut(&mut slice).as_uninit_slice_mut();
-    /// };
-    /// ```
-    #[inline]
-    pub unsafe fn as_uninit_slice_mut(&mut self) -> &mut [MaybeUninit<u8>] {
-        &mut self.0
-    }
-
-    /// Returns the number of bytes in the slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut data = [0, 1, 2];
-    /// let mut slice = &mut data[..];
-    /// let len = BufMut::chunk_mut(&mut slice).len();
-    ///
-    /// assert_eq!(len, 3);
-    /// ```
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-}
-
-impl fmt::Debug for UninitSlice {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.debug_struct("UninitSlice[...]").finish()
-    }
-}
-
-impl<'a> From<&'a mut [u8]> for &'a mut UninitSlice {
-    fn from(slice: &'a mut [u8]) -> Self {
-        UninitSlice::new(slice)
-    }
-}
-
-impl<'a> From<&'a mut [MaybeUninit<u8>]> for &'a mut UninitSlice {
-    fn from(slice: &'a mut [MaybeUninit<u8>]) -> Self {
-        UninitSlice::uninit(slice)
-    }
-}
-
-macro_rules! impl_index {
-    ($($t:ty),*) => {
-        $(
-            impl Index<$t> for UninitSlice {
-                type Output = UninitSlice;
-
-                #[inline]
-                fn index(&self, index: $t) -> &UninitSlice {
-                    UninitSlice::uninit_ref(&self.0[index])
-                }
-            }
-
-            impl IndexMut<$t> for UninitSlice {
-                #[inline]
-                fn index_mut(&mut self, index: $t) -> &mut UninitSlice {
-                    UninitSlice::uninit(&mut self.0[index])
-                }
-            }
-        )*
-    };
-}
-
-impl_index!(
-    Range<usize>,
-    RangeFrom<usize>,
-    RangeFull,
-    RangeInclusive<usize>,
-    RangeTo<usize>,
-    RangeToInclusive<usize>
-);
diff --git a/vendor/bytes/src/buf/vec_deque.rs b/vendor/bytes/src/buf/vec_deque.rs
deleted file mode 100644
index 55d5636b..00000000
--- a/vendor/bytes/src/buf/vec_deque.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use alloc::collections::VecDeque;
-#[cfg(feature = "std")]
-use std::io;
-
-use super::Buf;
-
-impl Buf for VecDeque<u8> {
-    fn remaining(&self) -> usize {
-        self.len()
-    }
-
-    fn chunk(&self) -> &[u8] {
-        let (s1, s2) = self.as_slices();
-        if s1.is_empty() {
-            s2
-        } else {
-            s1
-        }
-    }
-
-    #[cfg(feature = "std")]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [io::IoSlice<'a>]) -> usize {
-        if self.is_empty() || dst.is_empty() {
-            return 0;
-        }
-
-        let (s1, s2) = self.as_slices();
-        dst[0] = io::IoSlice::new(s1);
-        if s2.is_empty() || dst.len() == 1 {
-            return 1;
-        }
-
-        dst[1] = io::IoSlice::new(s2);
-        2
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        self.drain(..cnt);
-    }
-}
diff --git a/vendor/bytes/src/buf/writer.rs b/vendor/bytes/src/buf/writer.rs
deleted file mode 100644
index e72348f4..00000000
--- a/vendor/bytes/src/buf/writer.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use crate::BufMut;
-
-use std::{cmp, io};
-
-/// A `BufMut` adapter which implements `io::Write` for the inner value.
-///
-/// This struct is generally created by calling `writer()` on `BufMut`. See
-/// documentation of [`writer()`](BufMut::writer) for more
-/// details.
-#[derive(Debug)]
-pub struct Writer<B> {
-    buf: B,
-}
-
-pub fn new<B>(buf: B) -> Writer<B> {
-    Writer { buf }
-}
-
-impl<B: BufMut> Writer<B> {
-    /// Gets a reference to the underlying `BufMut`.
-    ///
-    /// It is inadvisable to directly write to the underlying `BufMut`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::BufMut;
-    ///
-    /// let buf = Vec::with_capacity(1024).writer();
-    ///
-    /// assert_eq!(1024, buf.get_ref().capacity());
-    /// ```
-    pub fn get_ref(&self) -> &B {
-        &self.buf
-    }
-
-    /// Gets a mutable reference to the underlying `BufMut`.
-    ///
-    /// It is inadvisable to directly write to the underlying `BufMut`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![].writer();
-    ///
-    /// buf.get_mut().reserve(1024);
-    ///
-    /// assert_eq!(1024, buf.get_ref().capacity());
-    /// ```
-    pub fn get_mut(&mut self) -> &mut B {
-        &mut self.buf
-    }
-
-    /// Consumes this `Writer`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::BufMut;
-    /// use std::io;
-    ///
-    /// let mut buf = vec![].writer();
-    /// let mut src = &b"hello world"[..];
-    ///
-    /// io::copy(&mut src, &mut buf).unwrap();
-    ///
-    /// let buf = buf.into_inner();
-    /// assert_eq!(*buf, b"hello world"[..]);
-    /// ```
-    pub fn into_inner(self) -> B {
-        self.buf
-    }
-}
-
-impl<B: BufMut + Sized> io::Write for Writer<B> {
-    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
-        let n = cmp::min(self.buf.remaining_mut(), src.len());
-
-        self.buf.put_slice(&src[..n]);
-        Ok(n)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
diff --git a/vendor/bytes/src/bytes.rs b/vendor/bytes/src/bytes.rs
deleted file mode 100644
index cdb6ea55..00000000
--- a/vendor/bytes/src/bytes.rs
+++ /dev/null
@@ -1,1680 +0,0 @@
-use core::iter::FromIterator;
-use core::mem::{self, ManuallyDrop};
-use core::ops::{Deref, RangeBounds};
-use core::ptr::NonNull;
-use core::{cmp, fmt, hash, ptr, slice, usize};
-
-use alloc::{
-    alloc::{dealloc, Layout},
-    borrow::Borrow,
-    boxed::Box,
-    string::String,
-    vec::Vec,
-};
-
-use crate::buf::IntoIter;
-#[allow(unused)]
-use crate::loom::sync::atomic::AtomicMut;
-use crate::loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
-use crate::{offset_from, Buf, BytesMut};
-
-/// A cheaply cloneable and sliceable chunk of contiguous memory.
-///
-/// `Bytes` is an efficient container for storing and operating on contiguous
-/// slices of memory. It is intended for use primarily in networking code, but
-/// could have applications elsewhere as well.
-///
-/// `Bytes` values facilitate zero-copy network programming by allowing multiple
-/// `Bytes` objects to point to the same underlying memory.
-///
-/// `Bytes` does not have a single implementation. It is an interface, whose
-/// exact behavior is implemented through dynamic dispatch in several underlying
-/// implementations of `Bytes`.
-///
-/// All `Bytes` implementations must fulfill the following requirements:
-/// - They are cheaply cloneable and thereby shareable between an unlimited amount
-///   of components, for example by modifying a reference count.
-/// - Instances can be sliced to refer to a subset of the original buffer.
-///
-/// ```
-/// use bytes::Bytes;
-///
-/// let mut mem = Bytes::from("Hello world");
-/// let a = mem.slice(0..5);
-///
-/// assert_eq!(a, "Hello");
-///
-/// let b = mem.split_to(6);
-///
-/// assert_eq!(mem, "world");
-/// assert_eq!(b, "Hello ");
-/// ```
-///
-/// # Memory layout
-///
-/// The `Bytes` struct itself is fairly small, limited to 4 `usize` fields used
-/// to track information about which segment of the underlying memory the
-/// `Bytes` handle has access to.
-///
-/// `Bytes` keeps both a pointer to the shared state containing the full memory
-/// slice and a pointer to the start of the region visible by the handle.
-/// `Bytes` also tracks the length of its view into the memory.
-///
-/// # Sharing
-///
-/// `Bytes` contains a vtable, which allows implementations of `Bytes` to define
-/// how sharing/cloning is implemented in detail.
-/// When `Bytes::clone()` is called, `Bytes` will call the vtable function for
-/// cloning the backing storage in order to share it behind multiple `Bytes`
-/// instances.
-///
-/// For `Bytes` implementations which refer to constant memory (e.g. created
-/// via `Bytes::from_static()`) the cloning implementation will be a no-op.
-///
-/// For `Bytes` implementations which point to a reference counted shared storage
-/// (e.g. an `Arc<[u8]>`), sharing will be implemented by increasing the
-/// reference count.
-///
-/// Due to this mechanism, multiple `Bytes` instances may point to the same
-/// shared memory region.
-/// Each `Bytes` instance can point to different sections within that
-/// memory region, and `Bytes` instances may or may not have overlapping views
-/// into the memory.
-///
-/// The following diagram visualizes a scenario where 2 `Bytes` instances make
-/// use of an `Arc`-based backing storage, and provide access to different views:
-///
-/// ```text
-///
-///    Arc ptrs                   ┌─────────┐
-///    ________________________ / │ Bytes 2 │
-///   /                           └─────────┘
-///  /          ┌───────────┐     |         |
-/// |_________/ │  Bytes 1  │     |         |
-/// |           └───────────┘     |         |
-/// |           |           | ___/ data     | tail
-/// |      data |      tail |/              |
-/// v           v           v               v
-/// ┌─────┬─────┬───────────┬───────────────┬─────┐
-/// │ Arc │     │           │               │     │
-/// └─────┴─────┴───────────┴───────────────┴─────┘
-/// ```
-pub struct Bytes {
-    ptr: *const u8,
-    len: usize,
-    // inlined "trait object"
-    data: AtomicPtr<()>,
-    vtable: &'static Vtable,
-}
-
-pub(crate) struct Vtable {
-    /// fn(data, ptr, len)
-    pub clone: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Bytes,
-    /// fn(data, ptr, len)
-    ///
-    /// takes `Bytes` to value
-    pub to_vec: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Vec<u8>,
-    pub to_mut: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> BytesMut,
-    /// fn(data)
-    pub is_unique: unsafe fn(&AtomicPtr<()>) -> bool,
-    /// fn(data, ptr, len)
-    pub drop: unsafe fn(&mut AtomicPtr<()>, *const u8, usize),
-}
-
-impl Bytes {
-    /// Creates a new empty `Bytes`.
-    ///
-    /// This will not allocate and the returned `Bytes` handle will be empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let b = Bytes::new();
-    /// assert_eq!(&b[..], b"");
-    /// ```
-    #[inline]
-    #[cfg(not(all(loom, test)))]
-    pub const fn new() -> Self {
-        // Make it a named const to work around
-        // "unsizing casts are not allowed in const fn"
-        const EMPTY: &[u8] = &[];
-        Bytes::from_static(EMPTY)
-    }
-
-    /// Creates a new empty `Bytes`.
-    #[cfg(all(loom, test))]
-    pub fn new() -> Self {
-        const EMPTY: &[u8] = &[];
-        Bytes::from_static(EMPTY)
-    }
-
-    /// Creates a new `Bytes` from a static slice.
-    ///
-    /// The returned `Bytes` will point directly to the static slice. There is
-    /// no allocating or copying.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let b = Bytes::from_static(b"hello");
-    /// assert_eq!(&b[..], b"hello");
-    /// ```
-    #[inline]
-    #[cfg(not(all(loom, test)))]
-    pub const fn from_static(bytes: &'static [u8]) -> Self {
-        Bytes {
-            ptr: bytes.as_ptr(),
-            len: bytes.len(),
-            data: AtomicPtr::new(ptr::null_mut()),
-            vtable: &STATIC_VTABLE,
-        }
-    }
-
-    /// Creates a new `Bytes` from a static slice.
-    #[cfg(all(loom, test))]
-    pub fn from_static(bytes: &'static [u8]) -> Self {
-        Bytes {
-            ptr: bytes.as_ptr(),
-            len: bytes.len(),
-            data: AtomicPtr::new(ptr::null_mut()),
-            vtable: &STATIC_VTABLE,
-        }
-    }
-
-    /// Creates a new `Bytes` with length zero and the given pointer as the address.
-    fn new_empty_with_ptr(ptr: *const u8) -> Self {
-        debug_assert!(!ptr.is_null());
-
-        // Detach this pointer's provenance from whichever allocation it came from, and reattach it
-        // to the provenance of the fake ZST [u8;0] at the same address.
-        let ptr = without_provenance(ptr as usize);
-
-        Bytes {
-            ptr,
-            len: 0,
-            data: AtomicPtr::new(ptr::null_mut()),
-            vtable: &STATIC_VTABLE,
-        }
-    }
-
-    /// Create [Bytes] with a buffer whose lifetime is controlled
-    /// via an explicit owner.
-    ///
-    /// A common use case is to zero-copy construct from mapped memory.
-    ///
-    /// ```
-    /// # struct File;
-    /// #
-    /// # impl File {
-    /// #     pub fn open(_: &str) -> Result<Self, ()> {
-    /// #         Ok(Self)
-    /// #     }
-    /// # }
-    /// #
-    /// # mod memmap2 {
-    /// #     pub struct Mmap;
-    /// #
-    /// #     impl Mmap {
-    /// #         pub unsafe fn map(_file: &super::File) -> Result<Self, ()> {
-    /// #             Ok(Self)
-    /// #         }
-    /// #     }
-    /// #
-    /// #     impl AsRef<[u8]> for Mmap {
-    /// #         fn as_ref(&self) -> &[u8] {
-    /// #             b"buf"
-    /// #         }
-    /// #     }
-    /// # }
-    /// use bytes::Bytes;
-    /// use memmap2::Mmap;
-    ///
-    /// # fn main() -> Result<(), ()> {
-    /// let file = File::open("upload_bundle.tar.gz")?;
-    /// let mmap = unsafe { Mmap::map(&file) }?;
-    /// let b = Bytes::from_owner(mmap);
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// The `owner` will be transferred to the constructed [Bytes] object, which
-    /// will ensure it is dropped once all remaining clones of the constructed
-    /// object are dropped. The owner will then be responsible for dropping the
-    /// specified region of memory as part of its [Drop] implementation.
-    ///
-    /// Note that converting [Bytes] constructed from an owner into a [BytesMut]
-    /// will always create a deep copy of the buffer into newly allocated memory.
-    pub fn from_owner<T>(owner: T) -> Self
-    where
-        T: AsRef<[u8]> + Send + 'static,
-    {
-        // Safety & Miri:
-        // The ownership of `owner` is first transferred to the `Owned` wrapper and `Bytes` object.
-        // This ensures that the owner is pinned in memory, allowing us to call `.as_ref()` safely
-        // since the lifetime of the owner is controlled by the lifetime of the new `Bytes` object,
-        // and the lifetime of the resulting borrowed `&[u8]` matches that of the owner.
-        // Note that this remains safe so long as we only call `.as_ref()` once.
-        //
-        // There are some additional special considerations here:
-        //   * We rely on Bytes's Drop impl to clean up memory should `.as_ref()` panic.
-        //   * Setting the `ptr` and `len` on the bytes object last (after moving the owner to
-        //     Bytes) allows Miri checks to pass since it avoids obtaining the `&[u8]` slice
-        //     from a stack-owned Box.
-        // More details on this: https://github.com/tokio-rs/bytes/pull/742/#discussion_r1813375863
-        //                  and: https://github.com/tokio-rs/bytes/pull/742/#discussion_r1813316032
-
-        let owned = Box::into_raw(Box::new(Owned {
-            lifetime: OwnedLifetime {
-                ref_cnt: AtomicUsize::new(1),
-                drop: owned_box_and_drop::<T>,
-            },
-            owner,
-        }));
-
-        let mut ret = Bytes {
-            ptr: NonNull::dangling().as_ptr(),
-            len: 0,
-            data: AtomicPtr::new(owned.cast()),
-            vtable: &OWNED_VTABLE,
-        };
-
-        let buf = unsafe { &*owned }.owner.as_ref();
-        ret.ptr = buf.as_ptr();
-        ret.len = buf.len();
-
-        ret
-    }
-
-    /// Returns the number of bytes contained in this `Bytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let b = Bytes::from(&b"hello"[..]);
-    /// assert_eq!(b.len(), 5);
-    /// ```
-    #[inline]
-    pub const fn len(&self) -> usize {
-        self.len
-    }
-
-    /// Returns true if the `Bytes` has a length of 0.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let b = Bytes::new();
-    /// assert!(b.is_empty());
-    /// ```
-    #[inline]
-    pub const fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    /// Returns true if this is the only reference to the data and
-    /// `Into<BytesMut>` would avoid cloning the underlying buffer.
-    ///
-    /// Always returns false if the data is backed by a [static slice](Bytes::from_static),
-    /// or an [owner](Bytes::from_owner).
-    ///
-    /// The result of this method may be invalidated immediately if another
-    /// thread clones this value while this is being called. Ensure you have
-    /// unique access to this value (`&mut Bytes`) first if you need to be
-    /// certain the result is valid (i.e. for safety reasons).
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let a = Bytes::from(vec![1, 2, 3]);
-    /// assert!(a.is_unique());
-    /// let b = a.clone();
-    /// assert!(!a.is_unique());
-    /// ```
-    pub fn is_unique(&self) -> bool {
-        unsafe { (self.vtable.is_unique)(&self.data) }
-    }
-
-    /// Creates `Bytes` instance from slice, by copying it.
-    pub fn copy_from_slice(data: &[u8]) -> Self {
-        data.to_vec().into()
-    }
-
-    /// Returns a slice of self for the provided range.
-    ///
-    /// This will increment the reference count for the underlying memory and
-    /// return a new `Bytes` handle set to the slice.
-    ///
-    /// This operation is `O(1)`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let a = Bytes::from(&b"hello world"[..]);
-    /// let b = a.slice(2..5);
-    ///
-    /// assert_eq!(&b[..], b"llo");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Requires that `begin <= end` and `end <= self.len()`, otherwise slicing
-    /// will panic.
-    pub fn slice(&self, range: impl RangeBounds<usize>) -> Self {
-        use core::ops::Bound;
-
-        let len = self.len();
-
-        let begin = match range.start_bound() {
-            Bound::Included(&n) => n,
-            Bound::Excluded(&n) => n.checked_add(1).expect("out of range"),
-            Bound::Unbounded => 0,
-        };
-
-        let end = match range.end_bound() {
-            Bound::Included(&n) => n.checked_add(1).expect("out of range"),
-            Bound::Excluded(&n) => n,
-            Bound::Unbounded => len,
-        };
-
-        assert!(
-            begin <= end,
-            "range start must not be greater than end: {:?} <= {:?}",
-            begin,
-            end,
-        );
-        assert!(
-            end <= len,
-            "range end out of bounds: {:?} <= {:?}",
-            end,
-            len,
-        );
-
-        if end == begin {
-            return Bytes::new();
-        }
-
-        let mut ret = self.clone();
-
-        ret.len = end - begin;
-        ret.ptr = unsafe { ret.ptr.add(begin) };
-
-        ret
-    }
-
-    /// Returns a slice of self that is equivalent to the given `subset`.
-    ///
-    /// When processing a `Bytes` buffer with other tools, one often gets a
-    /// `&[u8]` which is in fact a slice of the `Bytes`, i.e. a subset of it.
-    /// This function turns that `&[u8]` into another `Bytes`, as if one had
-    /// called `self.slice()` with the offsets that correspond to `subset`.
-    ///
-    /// This operation is `O(1)`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let bytes = Bytes::from(&b"012345678"[..]);
-    /// let as_slice = bytes.as_ref();
-    /// let subset = &as_slice[2..6];
-    /// let subslice = bytes.slice_ref(&subset);
-    /// assert_eq!(&subslice[..], b"2345");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Requires that the given `sub` slice is in fact contained within the
-    /// `Bytes` buffer; otherwise this function will panic.
-    pub fn slice_ref(&self, subset: &[u8]) -> Self {
-        // Empty slice and empty Bytes may have their pointers reset
-        // so explicitly allow empty slice to be a subslice of any slice.
-        if subset.is_empty() {
-            return Bytes::new();
-        }
-
-        let bytes_p = self.as_ptr() as usize;
-        let bytes_len = self.len();
-
-        let sub_p = subset.as_ptr() as usize;
-        let sub_len = subset.len();
-
-        assert!(
-            sub_p >= bytes_p,
-            "subset pointer ({:p}) is smaller than self pointer ({:p})",
-            subset.as_ptr(),
-            self.as_ptr(),
-        );
-        assert!(
-            sub_p + sub_len <= bytes_p + bytes_len,
-            "subset is out of bounds: self = ({:p}, {}), subset = ({:p}, {})",
-            self.as_ptr(),
-            bytes_len,
-            subset.as_ptr(),
-            sub_len,
-        );
-
-        let sub_offset = sub_p - bytes_p;
-
-        self.slice(sub_offset..(sub_offset + sub_len))
-    }
-
-    /// Splits the bytes into two at the given index.
-    ///
-    /// Afterwards `self` contains elements `[0, at)`, and the returned `Bytes`
-    /// contains elements `[at, len)`. It's guaranteed that the memory does not
-    /// move, that is, the address of `self` does not change, and the address of
-    /// the returned slice is `at` bytes after that.
-    ///
-    /// This is an `O(1)` operation that just increases the reference count and
-    /// sets a few indices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let mut a = Bytes::from(&b"hello world"[..]);
-    /// let b = a.split_off(5);
-    ///
-    /// assert_eq!(&a[..], b"hello");
-    /// assert_eq!(&b[..], b" world");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if `at > len`.
-    #[must_use = "consider Bytes::truncate if you don't need the other half"]
-    pub fn split_off(&mut self, at: usize) -> Self {
-        if at == self.len() {
-            return Bytes::new_empty_with_ptr(self.ptr.wrapping_add(at));
-        }
-
-        if at == 0 {
-            return mem::replace(self, Bytes::new_empty_with_ptr(self.ptr));
-        }
-
-        assert!(
-            at <= self.len(),
-            "split_off out of bounds: {:?} <= {:?}",
-            at,
-            self.len(),
-        );
-
-        let mut ret = self.clone();
-
-        self.len = at;
-
-        unsafe { ret.inc_start(at) };
-
-        ret
-    }
-
-    /// Splits the bytes into two at the given index.
-    ///
-    /// Afterwards `self` contains elements `[at, len)`, and the returned
-    /// `Bytes` contains elements `[0, at)`.
-    ///
-    /// This is an `O(1)` operation that just increases the reference count and
-    /// sets a few indices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let mut a = Bytes::from(&b"hello world"[..]);
-    /// let b = a.split_to(5);
-    ///
-    /// assert_eq!(&a[..], b" world");
-    /// assert_eq!(&b[..], b"hello");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if `at > len`.
-    #[must_use = "consider Bytes::advance if you don't need the other half"]
-    pub fn split_to(&mut self, at: usize) -> Self {
-        if at == self.len() {
-            let end_ptr = self.ptr.wrapping_add(at);
-            return mem::replace(self, Bytes::new_empty_with_ptr(end_ptr));
-        }
-
-        if at == 0 {
-            return Bytes::new_empty_with_ptr(self.ptr);
-        }
-
-        assert!(
-            at <= self.len(),
-            "split_to out of bounds: {:?} <= {:?}",
-            at,
-            self.len(),
-        );
-
-        let mut ret = self.clone();
-
-        unsafe { self.inc_start(at) };
-
-        ret.len = at;
-        ret
-    }
-
-    /// Shortens the buffer, keeping the first `len` bytes and dropping the
-    /// rest.
-    ///
-    /// If `len` is greater than the buffer's current length, this has no
-    /// effect.
-    ///
-    /// The [split_off](`Self::split_off()`) method can emulate `truncate`, but this causes the
-    /// excess bytes to be returned instead of dropped.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let mut buf = Bytes::from(&b"hello world"[..]);
-    /// buf.truncate(5);
-    /// assert_eq!(buf, b"hello"[..]);
-    /// ```
-    #[inline]
-    pub fn truncate(&mut self, len: usize) {
-        if len < self.len {
-            // The Vec "promotable" vtables do not store the capacity,
-            // so we cannot truncate while using this repr. We *have* to
-            // promote using `split_off` so the capacity can be stored.
-            if self.vtable as *const Vtable == &PROMOTABLE_EVEN_VTABLE
-                || self.vtable as *const Vtable == &PROMOTABLE_ODD_VTABLE
-            {
-                drop(self.split_off(len));
-            } else {
-                self.len = len;
-            }
-        }
-    }
-
-    /// Clears the buffer, removing all data.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let mut buf = Bytes::from(&b"hello world"[..]);
-    /// buf.clear();
-    /// assert!(buf.is_empty());
-    /// ```
-    #[inline]
-    pub fn clear(&mut self) {
-        self.truncate(0);
-    }
-
-    /// Try to convert self into `BytesMut`.
-    ///
-    /// If `self` is unique for the entire original buffer, this will succeed
-    /// and return a `BytesMut` with the contents of `self` without copying.
-    /// If `self` is not unique for the entire original buffer, this will fail
-    /// and return self.
-    ///
-    /// This will also always fail if the buffer was constructed via either
-    /// [from_owner](Bytes::from_owner) or [from_static](Bytes::from_static).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{Bytes, BytesMut};
-    ///
-    /// let bytes = Bytes::from(b"hello".to_vec());
-    /// assert_eq!(bytes.try_into_mut(), Ok(BytesMut::from(&b"hello"[..])));
-    /// ```
-    pub fn try_into_mut(self) -> Result<BytesMut, Bytes> {
-        if self.is_unique() {
-            Ok(self.into())
-        } else {
-            Err(self)
-        }
-    }
-
-    #[inline]
-    pub(crate) unsafe fn with_vtable(
-        ptr: *const u8,
-        len: usize,
-        data: AtomicPtr<()>,
-        vtable: &'static Vtable,
-    ) -> Bytes {
-        Bytes {
-            ptr,
-            len,
-            data,
-            vtable,
-        }
-    }
-
-    // private
-
-    #[inline]
-    fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.ptr, self.len) }
-    }
-
-    #[inline]
-    unsafe fn inc_start(&mut self, by: usize) {
-        // should already be asserted, but debug assert for tests
-        debug_assert!(self.len >= by, "internal: inc_start out of bounds");
-        self.len -= by;
-        self.ptr = self.ptr.add(by);
-    }
-}
-
-// Vtable must enforce this behavior
-unsafe impl Send for Bytes {}
-unsafe impl Sync for Bytes {}
-
-impl Drop for Bytes {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe { (self.vtable.drop)(&mut self.data, self.ptr, self.len) }
-    }
-}
-
-impl Clone for Bytes {
-    #[inline]
-    fn clone(&self) -> Bytes {
-        unsafe { (self.vtable.clone)(&self.data, self.ptr, self.len) }
-    }
-}
-
-impl Buf for Bytes {
-    #[inline]
-    fn remaining(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk(&self) -> &[u8] {
-        self.as_slice()
-    }
-
-    #[inline]
-    fn advance(&mut self, cnt: usize) {
-        assert!(
-            cnt <= self.len(),
-            "cannot advance past `remaining`: {:?} <= {:?}",
-            cnt,
-            self.len(),
-        );
-
-        unsafe {
-            self.inc_start(cnt);
-        }
-    }
-
-    fn copy_to_bytes(&mut self, len: usize) -> Self {
-        self.split_to(len)
-    }
-}
-
-impl Deref for Bytes {
-    type Target = [u8];
-
-    #[inline]
-    fn deref(&self) -> &[u8] {
-        self.as_slice()
-    }
-}
-
-impl AsRef<[u8]> for Bytes {
-    #[inline]
-    fn as_ref(&self) -> &[u8] {
-        self.as_slice()
-    }
-}
-
-impl hash::Hash for Bytes {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: hash::Hasher,
-    {
-        self.as_slice().hash(state);
-    }
-}
-
-impl Borrow<[u8]> for Bytes {
-    fn borrow(&self) -> &[u8] {
-        self.as_slice()
-    }
-}
-
-impl IntoIterator for Bytes {
-    type Item = u8;
-    type IntoIter = IntoIter<Bytes>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter::new(self)
-    }
-}
-
-impl<'a> IntoIterator for &'a Bytes {
-    type Item = &'a u8;
-    type IntoIter = core::slice::Iter<'a, u8>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.as_slice().iter()
-    }
-}
-
-impl FromIterator<u8> for Bytes {
-    fn from_iter<T: IntoIterator<Item = u8>>(into_iter: T) -> Self {
-        Vec::from_iter(into_iter).into()
-    }
-}
-
-// impl Eq
-
-impl PartialEq for Bytes {
-    fn eq(&self, other: &Bytes) -> bool {
-        self.as_slice() == other.as_slice()
-    }
-}
-
-impl PartialOrd for Bytes {
-    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
-        self.as_slice().partial_cmp(other.as_slice())
-    }
-}
-
-impl Ord for Bytes {
-    fn cmp(&self, other: &Bytes) -> cmp::Ordering {
-        self.as_slice().cmp(other.as_slice())
-    }
-}
-
-impl Eq for Bytes {}
-
-impl PartialEq<[u8]> for Bytes {
-    fn eq(&self, other: &[u8]) -> bool {
-        self.as_slice() == other
-    }
-}
-
-impl PartialOrd<[u8]> for Bytes {
-    fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
-        self.as_slice().partial_cmp(other)
-    }
-}
-
-impl PartialEq<Bytes> for [u8] {
-    fn eq(&self, other: &Bytes) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<Bytes> for [u8] {
-    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other)
-    }
-}
-
-impl PartialEq<str> for Bytes {
-    fn eq(&self, other: &str) -> bool {
-        self.as_slice() == other.as_bytes()
-    }
-}
-
-impl PartialOrd<str> for Bytes {
-    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
-        self.as_slice().partial_cmp(other.as_bytes())
-    }
-}
-
-impl PartialEq<Bytes> for str {
-    fn eq(&self, other: &Bytes) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<Bytes> for str {
-    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other)
-    }
-}
-
-impl PartialEq<Vec<u8>> for Bytes {
-    fn eq(&self, other: &Vec<u8>) -> bool {
-        *self == other[..]
-    }
-}
-
-impl PartialOrd<Vec<u8>> for Bytes {
-    fn partial_cmp(&self, other: &Vec<u8>) -> Option<cmp::Ordering> {
-        self.as_slice().partial_cmp(&other[..])
-    }
-}
-
-impl PartialEq<Bytes> for Vec<u8> {
-    fn eq(&self, other: &Bytes) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<Bytes> for Vec<u8> {
-    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other)
-    }
-}
-
-impl PartialEq<String> for Bytes {
-    fn eq(&self, other: &String) -> bool {
-        *self == other[..]
-    }
-}
-
-impl PartialOrd<String> for Bytes {
-    fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
-        self.as_slice().partial_cmp(other.as_bytes())
-    }
-}
-
-impl PartialEq<Bytes> for String {
-    fn eq(&self, other: &Bytes) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<Bytes> for String {
-    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other)
-    }
-}
-
-impl PartialEq<Bytes> for &[u8] {
-    fn eq(&self, other: &Bytes) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<Bytes> for &[u8] {
-    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other)
-    }
-}
-
-impl PartialEq<Bytes> for &str {
-    fn eq(&self, other: &Bytes) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<Bytes> for &str {
-    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other)
-    }
-}
-
-impl<'a, T: ?Sized> PartialEq<&'a T> for Bytes
-where
-    Bytes: PartialEq<T>,
-{
-    fn eq(&self, other: &&'a T) -> bool {
-        *self == **other
-    }
-}
-
-impl<'a, T: ?Sized> PartialOrd<&'a T> for Bytes
-where
-    Bytes: PartialOrd<T>,
-{
-    fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> {
-        self.partial_cmp(&**other)
-    }
-}
-
-// impl From
-
-impl Default for Bytes {
-    #[inline]
-    fn default() -> Bytes {
-        Bytes::new()
-    }
-}
-
-impl From<&'static [u8]> for Bytes {
-    fn from(slice: &'static [u8]) -> Bytes {
-        Bytes::from_static(slice)
-    }
-}
-
-impl From<&'static str> for Bytes {
-    fn from(slice: &'static str) -> Bytes {
-        Bytes::from_static(slice.as_bytes())
-    }
-}
-
-impl From<Vec<u8>> for Bytes {
-    fn from(vec: Vec<u8>) -> Bytes {
-        let mut vec = ManuallyDrop::new(vec);
-        let ptr = vec.as_mut_ptr();
-        let len = vec.len();
-        let cap = vec.capacity();
-
-        // Avoid an extra allocation if possible.
-        if len == cap {
-            let vec = ManuallyDrop::into_inner(vec);
-            return Bytes::from(vec.into_boxed_slice());
-        }
-
-        let shared = Box::new(Shared {
-            buf: ptr,
-            cap,
-            ref_cnt: AtomicUsize::new(1),
-        });
-
-        let shared = Box::into_raw(shared);
-        // The pointer should be aligned, so this assert should
-        // always succeed.
-        debug_assert!(
-            0 == (shared as usize & KIND_MASK),
-            "internal: Box<Shared> should have an aligned pointer",
-        );
-        Bytes {
-            ptr,
-            len,
-            data: AtomicPtr::new(shared as _),
-            vtable: &SHARED_VTABLE,
-        }
-    }
-}
-
-impl From<Box<[u8]>> for Bytes {
-    fn from(slice: Box<[u8]>) -> Bytes {
-        // Box<[u8]> doesn't contain a heap allocation for empty slices,
-        // so the pointer isn't aligned enough for the KIND_VEC stashing to
-        // work.
-        if slice.is_empty() {
-            return Bytes::new();
-        }
-
-        let len = slice.len();
-        let ptr = Box::into_raw(slice) as *mut u8;
-
-        if ptr as usize & 0x1 == 0 {
-            let data = ptr_map(ptr, |addr| addr | KIND_VEC);
-            Bytes {
-                ptr,
-                len,
-                data: AtomicPtr::new(data.cast()),
-                vtable: &PROMOTABLE_EVEN_VTABLE,
-            }
-        } else {
-            Bytes {
-                ptr,
-                len,
-                data: AtomicPtr::new(ptr.cast()),
-                vtable: &PROMOTABLE_ODD_VTABLE,
-            }
-        }
-    }
-}
-
-impl From<Bytes> for BytesMut {
-    /// Convert self into `BytesMut`.
-    ///
-    /// If `bytes` is unique for the entire original buffer, this will return a
-    /// `BytesMut` with the contents of `bytes` without copying.
-    /// If `bytes` is not unique for the entire original buffer, this will make
-    /// a copy of `bytes` subset of the original buffer in a new `BytesMut`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{Bytes, BytesMut};
-    ///
-    /// let bytes = Bytes::from(b"hello".to_vec());
-    /// assert_eq!(BytesMut::from(bytes), BytesMut::from(&b"hello"[..]));
-    /// ```
-    fn from(bytes: Bytes) -> Self {
-        let bytes = ManuallyDrop::new(bytes);
-        unsafe { (bytes.vtable.to_mut)(&bytes.data, bytes.ptr, bytes.len) }
-    }
-}
-
-impl From<String> for Bytes {
-    fn from(s: String) -> Bytes {
-        Bytes::from(s.into_bytes())
-    }
-}
-
-impl From<Bytes> for Vec<u8> {
-    fn from(bytes: Bytes) -> Vec<u8> {
-        let bytes = ManuallyDrop::new(bytes);
-        unsafe { (bytes.vtable.to_vec)(&bytes.data, bytes.ptr, bytes.len) }
-    }
-}
-
-// ===== impl Vtable =====
-
-impl fmt::Debug for Vtable {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Vtable")
-            .field("clone", &(self.clone as *const ()))
-            .field("drop", &(self.drop as *const ()))
-            .finish()
-    }
-}
-
-// ===== impl StaticVtable =====
-
-const STATIC_VTABLE: Vtable = Vtable {
-    clone: static_clone,
-    to_vec: static_to_vec,
-    to_mut: static_to_mut,
-    is_unique: static_is_unique,
-    drop: static_drop,
-};
-
-unsafe fn static_clone(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
-    let slice = slice::from_raw_parts(ptr, len);
-    Bytes::from_static(slice)
-}
-
-unsafe fn static_to_vec(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    let slice = slice::from_raw_parts(ptr, len);
-    slice.to_vec()
-}
-
-unsafe fn static_to_mut(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    let slice = slice::from_raw_parts(ptr, len);
-    BytesMut::from(slice)
-}
-
-fn static_is_unique(_: &AtomicPtr<()>) -> bool {
-    false
-}
-
-unsafe fn static_drop(_: &mut AtomicPtr<()>, _: *const u8, _: usize) {
-    // nothing to drop for &'static [u8]
-}
-
-// ===== impl OwnedVtable =====
-
-#[repr(C)]
-struct OwnedLifetime {
-    ref_cnt: AtomicUsize,
-    drop: unsafe fn(*mut ()),
-}
-
-#[repr(C)]
-struct Owned<T> {
-    lifetime: OwnedLifetime,
-    owner: T,
-}
-
-unsafe fn owned_box_and_drop<T>(ptr: *mut ()) {
-    let b: Box<Owned<T>> = Box::from_raw(ptr as _);
-    drop(b);
-}
-
-unsafe fn owned_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
-    let owned = data.load(Ordering::Relaxed);
-    let ref_cnt = &(*owned.cast::<OwnedLifetime>()).ref_cnt;
-    let old_cnt = ref_cnt.fetch_add(1, Ordering::Relaxed);
-    if old_cnt > usize::MAX >> 1 {
-        crate::abort()
-    }
-
-    Bytes {
-        ptr,
-        len,
-        data: AtomicPtr::new(owned as _),
-        vtable: &OWNED_VTABLE,
-    }
-}
-
-unsafe fn owned_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    let slice = slice::from_raw_parts(ptr, len);
-    let vec = slice.to_vec();
-    owned_drop_impl(data.load(Ordering::Relaxed));
-    vec
-}
-
-unsafe fn owned_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    BytesMut::from_vec(owned_to_vec(data, ptr, len))
-}
-
-unsafe fn owned_is_unique(_data: &AtomicPtr<()>) -> bool {
-    false
-}
-
-unsafe fn owned_drop_impl(owned: *mut ()) {
-    let lifetime = owned.cast::<OwnedLifetime>();
-    let ref_cnt = &(*lifetime).ref_cnt;
-
-    let old_cnt = ref_cnt.fetch_sub(1, Ordering::Release);
-    debug_assert!(
-        old_cnt > 0 && old_cnt <= usize::MAX >> 1,
-        "expected non-zero refcount and no underflow"
-    );
-    if old_cnt != 1 {
-        return;
-    }
-    ref_cnt.load(Ordering::Acquire);
-
-    let drop_fn = &(*lifetime).drop;
-    drop_fn(owned)
-}
-
-unsafe fn owned_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) {
-    let owned = data.load(Ordering::Relaxed);
-    owned_drop_impl(owned);
-}
-
-static OWNED_VTABLE: Vtable = Vtable {
-    clone: owned_clone,
-    to_vec: owned_to_vec,
-    to_mut: owned_to_mut,
-    is_unique: owned_is_unique,
-    drop: owned_drop,
-};
-
-// ===== impl PromotableVtable =====
-
-static PROMOTABLE_EVEN_VTABLE: Vtable = Vtable {
-    clone: promotable_even_clone,
-    to_vec: promotable_even_to_vec,
-    to_mut: promotable_even_to_mut,
-    is_unique: promotable_is_unique,
-    drop: promotable_even_drop,
-};
-
-static PROMOTABLE_ODD_VTABLE: Vtable = Vtable {
-    clone: promotable_odd_clone,
-    to_vec: promotable_odd_to_vec,
-    to_mut: promotable_odd_to_mut,
-    is_unique: promotable_is_unique,
-    drop: promotable_odd_drop,
-};
-
-unsafe fn promotable_even_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
-    let shared = data.load(Ordering::Acquire);
-    let kind = shared as usize & KIND_MASK;
-
-    if kind == KIND_ARC {
-        shallow_clone_arc(shared.cast(), ptr, len)
-    } else {
-        debug_assert_eq!(kind, KIND_VEC);
-        let buf = ptr_map(shared.cast(), |addr| addr & !KIND_MASK);
-        shallow_clone_vec(data, shared, buf, ptr, len)
-    }
-}
-
-unsafe fn promotable_to_vec(
-    data: &AtomicPtr<()>,
-    ptr: *const u8,
-    len: usize,
-    f: fn(*mut ()) -> *mut u8,
-) -> Vec<u8> {
-    let shared = data.load(Ordering::Acquire);
-    let kind = shared as usize & KIND_MASK;
-
-    if kind == KIND_ARC {
-        shared_to_vec_impl(shared.cast(), ptr, len)
-    } else {
-        // If Bytes holds a Vec, then the offset must be 0.
-        debug_assert_eq!(kind, KIND_VEC);
-
-        let buf = f(shared);
-
-        let cap = offset_from(ptr, buf) + len;
-
-        // Copy back buffer
-        ptr::copy(ptr, buf, len);
-
-        Vec::from_raw_parts(buf, len, cap)
-    }
-}
-
-unsafe fn promotable_to_mut(
-    data: &AtomicPtr<()>,
-    ptr: *const u8,
-    len: usize,
-    f: fn(*mut ()) -> *mut u8,
-) -> BytesMut {
-    let shared = data.load(Ordering::Acquire);
-    let kind = shared as usize & KIND_MASK;
-
-    if kind == KIND_ARC {
-        shared_to_mut_impl(shared.cast(), ptr, len)
-    } else {
-        // KIND_VEC is a view of an underlying buffer at a certain offset.
-        // The ptr + len always represents the end of that buffer.
-        // Before truncating it, it is first promoted to KIND_ARC.
-        // Thus, we can safely reconstruct a Vec from it without leaking memory.
-        debug_assert_eq!(kind, KIND_VEC);
-
-        let buf = f(shared);
-        let off = offset_from(ptr, buf);
-        let cap = off + len;
-        let v = Vec::from_raw_parts(buf, cap, cap);
-
-        let mut b = BytesMut::from_vec(v);
-        b.advance_unchecked(off);
-        b
-    }
-}
-
-unsafe fn promotable_even_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    promotable_to_vec(data, ptr, len, |shared| {
-        ptr_map(shared.cast(), |addr| addr & !KIND_MASK)
-    })
-}
-
-unsafe fn promotable_even_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    promotable_to_mut(data, ptr, len, |shared| {
-        ptr_map(shared.cast(), |addr| addr & !KIND_MASK)
-    })
-}
-
-unsafe fn promotable_even_drop(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) {
-    data.with_mut(|shared| {
-        let shared = *shared;
-        let kind = shared as usize & KIND_MASK;
-
-        if kind == KIND_ARC {
-            release_shared(shared.cast());
-        } else {
-            debug_assert_eq!(kind, KIND_VEC);
-            let buf = ptr_map(shared.cast(), |addr| addr & !KIND_MASK);
-            free_boxed_slice(buf, ptr, len);
-        }
-    });
-}
-
-unsafe fn promotable_odd_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
-    let shared = data.load(Ordering::Acquire);
-    let kind = shared as usize & KIND_MASK;
-
-    if kind == KIND_ARC {
-        shallow_clone_arc(shared as _, ptr, len)
-    } else {
-        debug_assert_eq!(kind, KIND_VEC);
-        shallow_clone_vec(data, shared, shared.cast(), ptr, len)
-    }
-}
-
-unsafe fn promotable_odd_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    promotable_to_vec(data, ptr, len, |shared| shared.cast())
-}
-
-unsafe fn promotable_odd_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    promotable_to_mut(data, ptr, len, |shared| shared.cast())
-}
-
-unsafe fn promotable_odd_drop(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) {
-    data.with_mut(|shared| {
-        let shared = *shared;
-        let kind = shared as usize & KIND_MASK;
-
-        if kind == KIND_ARC {
-            release_shared(shared.cast());
-        } else {
-            debug_assert_eq!(kind, KIND_VEC);
-
-            free_boxed_slice(shared.cast(), ptr, len);
-        }
-    });
-}
-
-unsafe fn promotable_is_unique(data: &AtomicPtr<()>) -> bool {
-    let shared = data.load(Ordering::Acquire);
-    let kind = shared as usize & KIND_MASK;
-
-    if kind == KIND_ARC {
-        let ref_cnt = (*shared.cast::<Shared>()).ref_cnt.load(Ordering::Relaxed);
-        ref_cnt == 1
-    } else {
-        true
-    }
-}
-
-unsafe fn free_boxed_slice(buf: *mut u8, offset: *const u8, len: usize) {
-    let cap = offset_from(offset, buf) + len;
-    dealloc(buf, Layout::from_size_align(cap, 1).unwrap())
-}
-
-// ===== impl SharedVtable =====
-
-struct Shared {
-    // Holds arguments to dealloc upon Drop, but otherwise doesn't use them
-    buf: *mut u8,
-    cap: usize,
-    ref_cnt: AtomicUsize,
-}
-
-impl Drop for Shared {
-    fn drop(&mut self) {
-        unsafe { dealloc(self.buf, Layout::from_size_align(self.cap, 1).unwrap()) }
-    }
-}
-
-// Assert that the alignment of `Shared` is divisible by 2.
-// This is a necessary invariant since we depend on allocating `Shared` a
-// shared object to implicitly carry the `KIND_ARC` flag in its pointer.
-// This flag is set when the LSB is 0.
-const _: [(); 0 - mem::align_of::<Shared>() % 2] = []; // Assert that the alignment of `Shared` is divisible by 2.
-
-static SHARED_VTABLE: Vtable = Vtable {
-    clone: shared_clone,
-    to_vec: shared_to_vec,
-    to_mut: shared_to_mut,
-    is_unique: shared_is_unique,
-    drop: shared_drop,
-};
-
-const KIND_ARC: usize = 0b0;
-const KIND_VEC: usize = 0b1;
-const KIND_MASK: usize = 0b1;
-
-unsafe fn shared_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
-    let shared = data.load(Ordering::Relaxed);
-    shallow_clone_arc(shared as _, ptr, len)
-}
-
-unsafe fn shared_to_vec_impl(shared: *mut Shared, ptr: *const u8, len: usize) -> Vec<u8> {
-    // Check that the ref_cnt is 1 (unique).
-    //
-    // If it is unique, then it is set to 0 with AcqRel fence for the same
-    // reason in release_shared.
-    //
-    // Otherwise, we take the other branch and call release_shared.
-    if (*shared)
-        .ref_cnt
-        .compare_exchange(1, 0, Ordering::AcqRel, Ordering::Relaxed)
-        .is_ok()
-    {
-        // Deallocate the `Shared` instance without running its destructor.
-        let shared = *Box::from_raw(shared);
-        let shared = ManuallyDrop::new(shared);
-        let buf = shared.buf;
-        let cap = shared.cap;
-
-        // Copy back buffer
-        ptr::copy(ptr, buf, len);
-
-        Vec::from_raw_parts(buf, len, cap)
-    } else {
-        let v = slice::from_raw_parts(ptr, len).to_vec();
-        release_shared(shared);
-        v
-    }
-}
-
-unsafe fn shared_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    shared_to_vec_impl(data.load(Ordering::Relaxed).cast(), ptr, len)
-}
-
-unsafe fn shared_to_mut_impl(shared: *mut Shared, ptr: *const u8, len: usize) -> BytesMut {
-    // The goal is to check if the current handle is the only handle
-    // that currently has access to the buffer. This is done by
-    // checking if the `ref_cnt` is currently 1.
-    //
-    // The `Acquire` ordering synchronizes with the `Release` as
-    // part of the `fetch_sub` in `release_shared`. The `fetch_sub`
-    // operation guarantees that any mutations done in other threads
-    // are ordered before the `ref_cnt` is decremented. As such,
-    // this `Acquire` will guarantee that those mutations are
-    // visible to the current thread.
-    //
-    // Otherwise, we take the other branch, copy the data and call `release_shared`.
-    if (*shared).ref_cnt.load(Ordering::Acquire) == 1 {
-        // Deallocate the `Shared` instance without running its destructor.
-        let shared = *Box::from_raw(shared);
-        let shared = ManuallyDrop::new(shared);
-        let buf = shared.buf;
-        let cap = shared.cap;
-
-        // Rebuild Vec
-        let off = offset_from(ptr, buf);
-        let v = Vec::from_raw_parts(buf, len + off, cap);
-
-        let mut b = BytesMut::from_vec(v);
-        b.advance_unchecked(off);
-        b
-    } else {
-        // Copy the data from Shared in a new Vec, then release it
-        let v = slice::from_raw_parts(ptr, len).to_vec();
-        release_shared(shared);
-        BytesMut::from_vec(v)
-    }
-}
-
-unsafe fn shared_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    shared_to_mut_impl(data.load(Ordering::Relaxed).cast(), ptr, len)
-}
-
-pub(crate) unsafe fn shared_is_unique(data: &AtomicPtr<()>) -> bool {
-    let shared = data.load(Ordering::Acquire);
-    let ref_cnt = (*shared.cast::<Shared>()).ref_cnt.load(Ordering::Relaxed);
-    ref_cnt == 1
-}
-
-unsafe fn shared_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) {
-    data.with_mut(|shared| {
-        release_shared(shared.cast());
-    });
-}
-
-unsafe fn shallow_clone_arc(shared: *mut Shared, ptr: *const u8, len: usize) -> Bytes {
-    let old_size = (*shared).ref_cnt.fetch_add(1, Ordering::Relaxed);
-
-    if old_size > usize::MAX >> 1 {
-        crate::abort();
-    }
-
-    Bytes {
-        ptr,
-        len,
-        data: AtomicPtr::new(shared as _),
-        vtable: &SHARED_VTABLE,
-    }
-}
-
-#[cold]
-unsafe fn shallow_clone_vec(
-    atom: &AtomicPtr<()>,
-    ptr: *const (),
-    buf: *mut u8,
-    offset: *const u8,
-    len: usize,
-) -> Bytes {
-    // If the buffer is still tracked in a `Vec<u8>`. It is time to
-    // promote the vec to an `Arc`. This could potentially be called
-    // concurrently, so some care must be taken.
-
-    // First, allocate a new `Shared` instance containing the
-    // `Vec` fields. It's important to note that `ptr`, `len`,
-    // and `cap` cannot be mutated without having `&mut self`.
-    // This means that these fields will not be concurrently
-    // updated and since the buffer hasn't been promoted to an
-    // `Arc`, those three fields still are the components of the
-    // vector.
-    let shared = Box::new(Shared {
-        buf,
-        cap: offset_from(offset, buf) + len,
-        // Initialize refcount to 2. One for this reference, and one
-        // for the new clone that will be returned from
-        // `shallow_clone`.
-        ref_cnt: AtomicUsize::new(2),
-    });
-
-    let shared = Box::into_raw(shared);
-
-    // The pointer should be aligned, so this assert should
-    // always succeed.
-    debug_assert!(
-        0 == (shared as usize & KIND_MASK),
-        "internal: Box<Shared> should have an aligned pointer",
-    );
-
-    // Try compare & swapping the pointer into the `arc` field.
-    // `Release` is used synchronize with other threads that
-    // will load the `arc` field.
-    //
-    // If the `compare_exchange` fails, then the thread lost the
-    // race to promote the buffer to shared. The `Acquire`
-    // ordering will synchronize with the `compare_exchange`
-    // that happened in the other thread and the `Shared`
-    // pointed to by `actual` will be visible.
-    match atom.compare_exchange(ptr as _, shared as _, Ordering::AcqRel, Ordering::Acquire) {
-        Ok(actual) => {
-            debug_assert!(actual as usize == ptr as usize);
-            // The upgrade was successful, the new handle can be
-            // returned.
-            Bytes {
-                ptr: offset,
-                len,
-                data: AtomicPtr::new(shared as _),
-                vtable: &SHARED_VTABLE,
-            }
-        }
-        Err(actual) => {
-            // The upgrade failed, a concurrent clone happened. Release
-            // the allocation that was made in this thread, it will not
-            // be needed.
-            let shared = Box::from_raw(shared);
-            mem::forget(*shared);
-
-            // Buffer already promoted to shared storage, so increment ref
-            // count.
-            shallow_clone_arc(actual as _, offset, len)
-        }
-    }
-}
-
-unsafe fn release_shared(ptr: *mut Shared) {
-    // `Shared` storage... follow the drop steps from Arc.
-    if (*ptr).ref_cnt.fetch_sub(1, Ordering::Release) != 1 {
-        return;
-    }
-
-    // This fence is needed to prevent reordering of use of the data and
-    // deletion of the data.  Because it is marked `Release`, the decreasing
-    // of the reference count synchronizes with this `Acquire` fence. This
-    // means that use of the data happens before decreasing the reference
-    // count, which happens before this fence, which happens before the
-    // deletion of the data.
-    //
-    // As explained in the [Boost documentation][1],
-    //
-    // > It is important to enforce any possible access to the object in one
-    // > thread (through an existing reference) to *happen before* deleting
-    // > the object in a different thread. This is achieved by a "release"
-    // > operation after dropping a reference (any access to the object
-    // > through this reference must obviously happened before), and an
-    // > "acquire" operation before deleting the object.
-    //
-    // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
-    //
-    // Thread sanitizer does not support atomic fences. Use an atomic load
-    // instead.
-    (*ptr).ref_cnt.load(Ordering::Acquire);
-
-    // Drop the data
-    drop(Box::from_raw(ptr));
-}
-
-// Ideally we would always use this version of `ptr_map` since it is strict
-// provenance compatible, but it results in worse codegen. We will however still
-// use it on miri because it gives better diagnostics for people who test bytes
-// code with miri.
-//
-// See https://github.com/tokio-rs/bytes/pull/545 for more info.
-#[cfg(miri)]
-fn ptr_map<F>(ptr: *mut u8, f: F) -> *mut u8
-where
-    F: FnOnce(usize) -> usize,
-{
-    let old_addr = ptr as usize;
-    let new_addr = f(old_addr);
-    let diff = new_addr.wrapping_sub(old_addr);
-    ptr.wrapping_add(diff)
-}
-
-#[cfg(not(miri))]
-fn ptr_map<F>(ptr: *mut u8, f: F) -> *mut u8
-where
-    F: FnOnce(usize) -> usize,
-{
-    let old_addr = ptr as usize;
-    let new_addr = f(old_addr);
-    new_addr as *mut u8
-}
-
-fn without_provenance(ptr: usize) -> *const u8 {
-    core::ptr::null::<u8>().wrapping_add(ptr)
-}
-
-// compile-fails
-
-/// ```compile_fail
-/// use bytes::Bytes;
-/// #[deny(unused_must_use)]
-/// {
-///     let mut b1 = Bytes::from("hello world");
-///     b1.split_to(6);
-/// }
-/// ```
-fn _split_to_must_use() {}
-
-/// ```compile_fail
-/// use bytes::Bytes;
-/// #[deny(unused_must_use)]
-/// {
-///     let mut b1 = Bytes::from("hello world");
-///     b1.split_off(6);
-/// }
-/// ```
-fn _split_off_must_use() {}
-
-// fuzz tests
-#[cfg(all(test, loom))]
-mod fuzz {
-    use loom::sync::Arc;
-    use loom::thread;
-
-    use super::Bytes;
-    #[test]
-    fn bytes_cloning_vec() {
-        loom::model(|| {
-            let a = Bytes::from(b"abcdefgh".to_vec());
-            let addr = a.as_ptr() as usize;
-
-            // test the Bytes::clone is Sync by putting it in an Arc
-            let a1 = Arc::new(a);
-            let a2 = a1.clone();
-
-            let t1 = thread::spawn(move || {
-                let b: Bytes = (*a1).clone();
-                assert_eq!(b.as_ptr() as usize, addr);
-            });
-
-            let t2 = thread::spawn(move || {
-                let b: Bytes = (*a2).clone();
-                assert_eq!(b.as_ptr() as usize, addr);
-            });
-
-            t1.join().unwrap();
-            t2.join().unwrap();
-        });
-    }
-}
diff --git a/vendor/bytes/src/bytes_mut.rs b/vendor/bytes/src/bytes_mut.rs
deleted file mode 100644
index d5db5124..00000000
--- a/vendor/bytes/src/bytes_mut.rs
+++ /dev/null
@@ -1,1921 +0,0 @@
-use core::iter::FromIterator;
-use core::mem::{self, ManuallyDrop, MaybeUninit};
-use core::ops::{Deref, DerefMut};
-use core::ptr::{self, NonNull};
-use core::{cmp, fmt, hash, isize, slice, usize};
-
-use alloc::{
-    borrow::{Borrow, BorrowMut},
-    boxed::Box,
-    string::String,
-    vec,
-    vec::Vec,
-};
-
-use crate::buf::{IntoIter, UninitSlice};
-use crate::bytes::Vtable;
-#[allow(unused)]
-use crate::loom::sync::atomic::AtomicMut;
-use crate::loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
-use crate::{offset_from, Buf, BufMut, Bytes, TryGetError};
-
-/// A unique reference to a contiguous slice of memory.
-///
-/// `BytesMut` represents a unique view into a potentially shared memory region.
-/// Given the uniqueness guarantee, owners of `BytesMut` handles are able to
-/// mutate the memory.
-///
-/// `BytesMut` can be thought of as containing a `buf: Arc<Vec<u8>>`, an offset
-/// into `buf`, a slice length, and a guarantee that no other `BytesMut` for the
-/// same `buf` overlaps with its slice. That guarantee means that a write lock
-/// is not required.
-///
-/// # Growth
-///
-/// `BytesMut`'s `BufMut` implementation will implicitly grow its buffer as
-/// necessary. However, explicitly reserving the required space up-front before
-/// a series of inserts will be more efficient.
-///
-/// # Examples
-///
-/// ```
-/// use bytes::{BytesMut, BufMut};
-///
-/// let mut buf = BytesMut::with_capacity(64);
-///
-/// buf.put_u8(b'h');
-/// buf.put_u8(b'e');
-/// buf.put(&b"llo"[..]);
-///
-/// assert_eq!(&buf[..], b"hello");
-///
-/// // Freeze the buffer so that it can be shared
-/// let a = buf.freeze();
-///
-/// // This does not allocate, instead `b` points to the same memory.
-/// let b = a.clone();
-///
-/// assert_eq!(&a[..], b"hello");
-/// assert_eq!(&b[..], b"hello");
-/// ```
-pub struct BytesMut {
-    ptr: NonNull<u8>,
-    len: usize,
-    cap: usize,
-    data: *mut Shared,
-}
-
-// Thread-safe reference-counted container for the shared storage. This mostly
-// the same as `core::sync::Arc` but without the weak counter. The ref counting
-// fns are based on the ones found in `std`.
-//
-// The main reason to use `Shared` instead of `core::sync::Arc` is that it ends
-// up making the overall code simpler and easier to reason about. This is due to
-// some of the logic around setting `Inner::arc` and other ways the `arc` field
-// is used. Using `Arc` ended up requiring a number of funky transmutes and
-// other shenanigans to make it work.
-struct Shared {
-    vec: Vec<u8>,
-    original_capacity_repr: usize,
-    ref_count: AtomicUsize,
-}
-
-// Assert that the alignment of `Shared` is divisible by 2.
-// This is a necessary invariant since we depend on allocating `Shared` a
-// shared object to implicitly carry the `KIND_ARC` flag in its pointer.
-// This flag is set when the LSB is 0.
-const _: [(); 0 - mem::align_of::<Shared>() % 2] = []; // Assert that the alignment of `Shared` is divisible by 2.
-
-// Buffer storage strategy flags.
-const KIND_ARC: usize = 0b0;
-const KIND_VEC: usize = 0b1;
-const KIND_MASK: usize = 0b1;
-
-// The max original capacity value. Any `Bytes` allocated with a greater initial
-// capacity will default to this.
-const MAX_ORIGINAL_CAPACITY_WIDTH: usize = 17;
-// The original capacity algorithm will not take effect unless the originally
-// allocated capacity was at least 1kb in size.
-const MIN_ORIGINAL_CAPACITY_WIDTH: usize = 10;
-// The original capacity is stored in powers of 2 starting at 1kb to a max of
-// 64kb. Representing it as such requires only 3 bits of storage.
-const ORIGINAL_CAPACITY_MASK: usize = 0b11100;
-const ORIGINAL_CAPACITY_OFFSET: usize = 2;
-
-const VEC_POS_OFFSET: usize = 5;
-// When the storage is in the `Vec` representation, the pointer can be advanced
-// at most this value. This is due to the amount of storage available to track
-// the offset is usize - number of KIND bits and number of ORIGINAL_CAPACITY
-// bits.
-const MAX_VEC_POS: usize = usize::MAX >> VEC_POS_OFFSET;
-const NOT_VEC_POS_MASK: usize = 0b11111;
-
-#[cfg(target_pointer_width = "64")]
-const PTR_WIDTH: usize = 64;
-#[cfg(target_pointer_width = "32")]
-const PTR_WIDTH: usize = 32;
-
-/*
- *
- * ===== BytesMut =====
- *
- */
-
-impl BytesMut {
-    /// Creates a new `BytesMut` with the specified capacity.
-    ///
-    /// The returned `BytesMut` will be able to hold at least `capacity` bytes
-    /// without reallocating.
-    ///
-    /// It is important to note that this function does not specify the length
-    /// of the returned `BytesMut`, but only the capacity.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{BytesMut, BufMut};
-    ///
-    /// let mut bytes = BytesMut::with_capacity(64);
-    ///
-    /// // `bytes` contains no data, even though there is capacity
-    /// assert_eq!(bytes.len(), 0);
-    ///
-    /// bytes.put(&b"hello world"[..]);
-    ///
-    /// assert_eq!(&bytes[..], b"hello world");
-    /// ```
-    #[inline]
-    pub fn with_capacity(capacity: usize) -> BytesMut {
-        BytesMut::from_vec(Vec::with_capacity(capacity))
-    }
-
-    /// Creates a new `BytesMut` with default capacity.
-    ///
-    /// Resulting object has length 0 and unspecified capacity.
-    /// This function does not allocate.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{BytesMut, BufMut};
-    ///
-    /// let mut bytes = BytesMut::new();
-    ///
-    /// assert_eq!(0, bytes.len());
-    ///
-    /// bytes.reserve(2);
-    /// bytes.put_slice(b"xy");
-    ///
-    /// assert_eq!(&b"xy"[..], &bytes[..]);
-    /// ```
-    #[inline]
-    pub fn new() -> BytesMut {
-        BytesMut::with_capacity(0)
-    }
-
-    /// Returns the number of bytes contained in this `BytesMut`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let b = BytesMut::from(&b"hello"[..]);
-    /// assert_eq!(b.len(), 5);
-    /// ```
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    /// Returns true if the `BytesMut` has a length of 0.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let b = BytesMut::with_capacity(64);
-    /// assert!(b.is_empty());
-    /// ```
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    /// Returns the number of bytes the `BytesMut` can hold without reallocating.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let b = BytesMut::with_capacity(64);
-    /// assert_eq!(b.capacity(), 64);
-    /// ```
-    #[inline]
-    pub fn capacity(&self) -> usize {
-        self.cap
-    }
-
-    /// Converts `self` into an immutable `Bytes`.
-    ///
-    /// The conversion is zero cost and is used to indicate that the slice
-    /// referenced by the handle will no longer be mutated. Once the conversion
-    /// is done, the handle can be cloned and shared across threads.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{BytesMut, BufMut};
-    /// use std::thread;
-    ///
-    /// let mut b = BytesMut::with_capacity(64);
-    /// b.put(&b"hello world"[..]);
-    /// let b1 = b.freeze();
-    /// let b2 = b1.clone();
-    ///
-    /// let th = thread::spawn(move || {
-    ///     assert_eq!(&b1[..], b"hello world");
-    /// });
-    ///
-    /// assert_eq!(&b2[..], b"hello world");
-    /// th.join().unwrap();
-    /// ```
-    #[inline]
-    pub fn freeze(self) -> Bytes {
-        let bytes = ManuallyDrop::new(self);
-        if bytes.kind() == KIND_VEC {
-            // Just re-use `Bytes` internal Vec vtable
-            unsafe {
-                let off = bytes.get_vec_pos();
-                let vec = rebuild_vec(bytes.ptr.as_ptr(), bytes.len, bytes.cap, off);
-                let mut b: Bytes = vec.into();
-                b.advance(off);
-                b
-            }
-        } else {
-            debug_assert_eq!(bytes.kind(), KIND_ARC);
-
-            let ptr = bytes.ptr.as_ptr();
-            let len = bytes.len;
-            let data = AtomicPtr::new(bytes.data.cast());
-            unsafe { Bytes::with_vtable(ptr, len, data, &SHARED_VTABLE) }
-        }
-    }
-
-    /// Creates a new `BytesMut` containing `len` zeros.
-    ///
-    /// The resulting object has a length of `len` and a capacity greater
-    /// than or equal to `len`. The entire length of the object will be filled
-    /// with zeros.
-    ///
-    /// On some platforms or allocators this function may be faster than
-    /// a manual implementation.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let zeros = BytesMut::zeroed(42);
-    ///
-    /// assert!(zeros.capacity() >= 42);
-    /// assert_eq!(zeros.len(), 42);
-    /// zeros.into_iter().for_each(|x| assert_eq!(x, 0));
-    /// ```
-    pub fn zeroed(len: usize) -> BytesMut {
-        BytesMut::from_vec(vec![0; len])
-    }
-
-    /// Splits the bytes into two at the given index.
-    ///
-    /// Afterwards `self` contains elements `[0, at)`, and the returned
-    /// `BytesMut` contains elements `[at, capacity)`. It's guaranteed that the
-    /// memory does not move, that is, the address of `self` does not change,
-    /// and the address of the returned slice is `at` bytes after that.
-    ///
-    /// This is an `O(1)` operation that just increases the reference count
-    /// and sets a few indices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut a = BytesMut::from(&b"hello world"[..]);
-    /// let mut b = a.split_off(5);
-    ///
-    /// a[0] = b'j';
-    /// b[0] = b'!';
-    ///
-    /// assert_eq!(&a[..], b"jello");
-    /// assert_eq!(&b[..], b"!world");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if `at > capacity`.
-    #[must_use = "consider BytesMut::truncate if you don't need the other half"]
-    pub fn split_off(&mut self, at: usize) -> BytesMut {
-        assert!(
-            at <= self.capacity(),
-            "split_off out of bounds: {:?} <= {:?}",
-            at,
-            self.capacity(),
-        );
-        unsafe {
-            let mut other = self.shallow_clone();
-            // SAFETY: We've checked that `at` <= `self.capacity()` above.
-            other.advance_unchecked(at);
-            self.cap = at;
-            self.len = cmp::min(self.len, at);
-            other
-        }
-    }
-
-    /// Removes the bytes from the current view, returning them in a new
-    /// `BytesMut` handle.
-    ///
-    /// Afterwards, `self` will be empty, but will retain any additional
-    /// capacity that it had before the operation. This is identical to
-    /// `self.split_to(self.len())`.
-    ///
-    /// This is an `O(1)` operation that just increases the reference count and
-    /// sets a few indices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{BytesMut, BufMut};
-    ///
-    /// let mut buf = BytesMut::with_capacity(1024);
-    /// buf.put(&b"hello world"[..]);
-    ///
-    /// let other = buf.split();
-    ///
-    /// assert!(buf.is_empty());
-    /// assert_eq!(1013, buf.capacity());
-    ///
-    /// assert_eq!(other, b"hello world"[..]);
-    /// ```
-    #[must_use = "consider BytesMut::clear if you don't need the other half"]
-    pub fn split(&mut self) -> BytesMut {
-        let len = self.len();
-        self.split_to(len)
-    }
-
-    /// Splits the buffer into two at the given index.
-    ///
-    /// Afterwards `self` contains elements `[at, len)`, and the returned `BytesMut`
-    /// contains elements `[0, at)`.
-    ///
-    /// This is an `O(1)` operation that just increases the reference count and
-    /// sets a few indices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut a = BytesMut::from(&b"hello world"[..]);
-    /// let mut b = a.split_to(5);
-    ///
-    /// a[0] = b'!';
-    /// b[0] = b'j';
-    ///
-    /// assert_eq!(&a[..], b"!world");
-    /// assert_eq!(&b[..], b"jello");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if `at > len`.
-    #[must_use = "consider BytesMut::advance if you don't need the other half"]
-    pub fn split_to(&mut self, at: usize) -> BytesMut {
-        assert!(
-            at <= self.len(),
-            "split_to out of bounds: {:?} <= {:?}",
-            at,
-            self.len(),
-        );
-
-        unsafe {
-            let mut other = self.shallow_clone();
-            // SAFETY: We've checked that `at` <= `self.len()` and we know that `self.len()` <=
-            // `self.capacity()`.
-            self.advance_unchecked(at);
-            other.cap = at;
-            other.len = at;
-            other
-        }
-    }
-
-    /// Shortens the buffer, keeping the first `len` bytes and dropping the
-    /// rest.
-    ///
-    /// If `len` is greater than the buffer's current length, this has no
-    /// effect.
-    ///
-    /// Existing underlying capacity is preserved.
-    ///
-    /// The [split_off](`Self::split_off()`) method can emulate `truncate`, but this causes the
-    /// excess bytes to be returned instead of dropped.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut buf = BytesMut::from(&b"hello world"[..]);
-    /// buf.truncate(5);
-    /// assert_eq!(buf, b"hello"[..]);
-    /// ```
-    pub fn truncate(&mut self, len: usize) {
-        if len <= self.len() {
-            // SAFETY: Shrinking the buffer cannot expose uninitialized bytes.
-            unsafe { self.set_len(len) };
-        }
-    }
-
-    /// Clears the buffer, removing all data. Existing capacity is preserved.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut buf = BytesMut::from(&b"hello world"[..]);
-    /// buf.clear();
-    /// assert!(buf.is_empty());
-    /// ```
-    pub fn clear(&mut self) {
-        // SAFETY: Setting the length to zero cannot expose uninitialized bytes.
-        unsafe { self.set_len(0) };
-    }
-
-    /// Resizes the buffer so that `len` is equal to `new_len`.
-    ///
-    /// If `new_len` is greater than `len`, the buffer is extended by the
-    /// difference with each additional byte set to `value`. If `new_len` is
-    /// less than `len`, the buffer is simply truncated.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut buf = BytesMut::new();
-    ///
-    /// buf.resize(3, 0x1);
-    /// assert_eq!(&buf[..], &[0x1, 0x1, 0x1]);
-    ///
-    /// buf.resize(2, 0x2);
-    /// assert_eq!(&buf[..], &[0x1, 0x1]);
-    ///
-    /// buf.resize(4, 0x3);
-    /// assert_eq!(&buf[..], &[0x1, 0x1, 0x3, 0x3]);
-    /// ```
-    pub fn resize(&mut self, new_len: usize, value: u8) {
-        let additional = if let Some(additional) = new_len.checked_sub(self.len()) {
-            additional
-        } else {
-            self.truncate(new_len);
-            return;
-        };
-
-        if additional == 0 {
-            return;
-        }
-
-        self.reserve(additional);
-        let dst = self.spare_capacity_mut().as_mut_ptr();
-        // SAFETY: `spare_capacity_mut` returns a valid, properly aligned pointer and we've
-        // reserved enough space to write `additional` bytes.
-        unsafe { ptr::write_bytes(dst, value, additional) };
-
-        // SAFETY: There are at least `new_len` initialized bytes in the buffer so no
-        // uninitialized bytes are being exposed.
-        unsafe { self.set_len(new_len) };
-    }
-
-    /// Sets the length of the buffer.
-    ///
-    /// This will explicitly set the size of the buffer without actually
-    /// modifying the data, so it is up to the caller to ensure that the data
-    /// has been initialized.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut b = BytesMut::from(&b"hello world"[..]);
-    ///
-    /// unsafe {
-    ///     b.set_len(5);
-    /// }
-    ///
-    /// assert_eq!(&b[..], b"hello");
-    ///
-    /// unsafe {
-    ///     b.set_len(11);
-    /// }
-    ///
-    /// assert_eq!(&b[..], b"hello world");
-    /// ```
-    #[inline]
-    pub unsafe fn set_len(&mut self, len: usize) {
-        debug_assert!(len <= self.cap, "set_len out of bounds");
-        self.len = len;
-    }
-
-    /// Reserves capacity for at least `additional` more bytes to be inserted
-    /// into the given `BytesMut`.
-    ///
-    /// More than `additional` bytes may be reserved in order to avoid frequent
-    /// reallocations. A call to `reserve` may result in an allocation.
-    ///
-    /// Before allocating new buffer space, the function will attempt to reclaim
-    /// space in the existing buffer. If the current handle references a view
-    /// into a larger original buffer, and all other handles referencing part
-    /// of the same original buffer have been dropped, then the current view
-    /// can be copied/shifted to the front of the buffer and the handle can take
-    /// ownership of the full buffer, provided that the full buffer is large
-    /// enough to fit the requested additional capacity.
-    ///
-    /// This optimization will only happen if shifting the data from the current
-    /// view to the front of the buffer is not too expensive in terms of the
-    /// (amortized) time required. The precise condition is subject to change;
-    /// as of now, the length of the data being shifted needs to be at least as
-    /// large as the distance that it's shifted by. If the current view is empty
-    /// and the original buffer is large enough to fit the requested additional
-    /// capacity, then reallocations will never happen.
-    ///
-    /// # Examples
-    ///
-    /// In the following example, a new buffer is allocated.
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut buf = BytesMut::from(&b"hello"[..]);
-    /// buf.reserve(64);
-    /// assert!(buf.capacity() >= 69);
-    /// ```
-    ///
-    /// In the following example, the existing buffer is reclaimed.
-    ///
-    /// ```
-    /// use bytes::{BytesMut, BufMut};
-    ///
-    /// let mut buf = BytesMut::with_capacity(128);
-    /// buf.put(&[0; 64][..]);
-    ///
-    /// let ptr = buf.as_ptr();
-    /// let other = buf.split();
-    ///
-    /// assert!(buf.is_empty());
-    /// assert_eq!(buf.capacity(), 64);
-    ///
-    /// drop(other);
-    /// buf.reserve(128);
-    ///
-    /// assert_eq!(buf.capacity(), 128);
-    /// assert_eq!(buf.as_ptr(), ptr);
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    #[inline]
-    pub fn reserve(&mut self, additional: usize) {
-        let len = self.len();
-        let rem = self.capacity() - len;
-
-        if additional <= rem {
-            // The handle can already store at least `additional` more bytes, so
-            // there is no further work needed to be done.
-            return;
-        }
-
-        // will always succeed
-        let _ = self.reserve_inner(additional, true);
-    }
-
-    // In separate function to allow the short-circuits in `reserve` and `try_reclaim` to
-    // be inline-able. Significantly helps performance. Returns false if it did not succeed.
-    fn reserve_inner(&mut self, additional: usize, allocate: bool) -> bool {
-        let len = self.len();
-        let kind = self.kind();
-
-        if kind == KIND_VEC {
-            // If there's enough free space before the start of the buffer, then
-            // just copy the data backwards and reuse the already-allocated
-            // space.
-            //
-            // Otherwise, since backed by a vector, use `Vec::reserve`
-            //
-            // We need to make sure that this optimization does not kill the
-            // amortized runtimes of BytesMut's operations.
-            unsafe {
-                let off = self.get_vec_pos();
-
-                // Only reuse space if we can satisfy the requested additional space.
-                //
-                // Also check if the value of `off` suggests that enough bytes
-                // have been read to account for the overhead of shifting all
-                // the data (in an amortized analysis).
-                // Hence the condition `off >= self.len()`.
-                //
-                // This condition also already implies that the buffer is going
-                // to be (at least) half-empty in the end; so we do not break
-                // the (amortized) runtime with future resizes of the underlying
-                // `Vec`.
-                //
-                // [For more details check issue #524, and PR #525.]
-                if self.capacity() - self.len() + off >= additional && off >= self.len() {
-                    // There's enough space, and it's not too much overhead:
-                    // reuse the space!
-                    //
-                    // Just move the pointer back to the start after copying
-                    // data back.
-                    let base_ptr = self.ptr.as_ptr().sub(off);
-                    // Since `off >= self.len()`, the two regions don't overlap.
-                    ptr::copy_nonoverlapping(self.ptr.as_ptr(), base_ptr, self.len);
-                    self.ptr = vptr(base_ptr);
-                    self.set_vec_pos(0);
-
-                    // Length stays constant, but since we moved backwards we
-                    // can gain capacity back.
-                    self.cap += off;
-                } else {
-                    if !allocate {
-                        return false;
-                    }
-                    // Not enough space, or reusing might be too much overhead:
-                    // allocate more space!
-                    let mut v =
-                        ManuallyDrop::new(rebuild_vec(self.ptr.as_ptr(), self.len, self.cap, off));
-                    v.reserve(additional);
-
-                    // Update the info
-                    self.ptr = vptr(v.as_mut_ptr().add(off));
-                    self.cap = v.capacity() - off;
-                    debug_assert_eq!(self.len, v.len() - off);
-                }
-
-                return true;
-            }
-        }
-
-        debug_assert_eq!(kind, KIND_ARC);
-        let shared: *mut Shared = self.data;
-
-        // Reserving involves abandoning the currently shared buffer and
-        // allocating a new vector with the requested capacity.
-        //
-        // Compute the new capacity
-        let mut new_cap = match len.checked_add(additional) {
-            Some(new_cap) => new_cap,
-            None if !allocate => return false,
-            None => panic!("overflow"),
-        };
-
-        unsafe {
-            // First, try to reclaim the buffer. This is possible if the current
-            // handle is the only outstanding handle pointing to the buffer.
-            if (*shared).is_unique() {
-                // This is the only handle to the buffer. It can be reclaimed.
-                // However, before doing the work of copying data, check to make
-                // sure that the vector has enough capacity.
-                let v = &mut (*shared).vec;
-
-                let v_capacity = v.capacity();
-                let ptr = v.as_mut_ptr();
-
-                let offset = offset_from(self.ptr.as_ptr(), ptr);
-
-                // Compare the condition in the `kind == KIND_VEC` case above
-                // for more details.
-                if v_capacity >= new_cap + offset {
-                    self.cap = new_cap;
-                    // no copy is necessary
-                } else if v_capacity >= new_cap && offset >= len {
-                    // The capacity is sufficient, and copying is not too much
-                    // overhead: reclaim the buffer!
-
-                    // `offset >= len` means: no overlap
-                    ptr::copy_nonoverlapping(self.ptr.as_ptr(), ptr, len);
-
-                    self.ptr = vptr(ptr);
-                    self.cap = v.capacity();
-                } else {
-                    if !allocate {
-                        return false;
-                    }
-                    // calculate offset
-                    let off = (self.ptr.as_ptr() as usize) - (v.as_ptr() as usize);
-
-                    // new_cap is calculated in terms of `BytesMut`, not the underlying
-                    // `Vec`, so it does not take the offset into account.
-                    //
-                    // Thus we have to manually add it here.
-                    new_cap = new_cap.checked_add(off).expect("overflow");
-
-                    // The vector capacity is not sufficient. The reserve request is
-                    // asking for more than the initial buffer capacity. Allocate more
-                    // than requested if `new_cap` is not much bigger than the current
-                    // capacity.
-                    //
-                    // There are some situations, using `reserve_exact` that the
-                    // buffer capacity could be below `original_capacity`, so do a
-                    // check.
-                    let double = v.capacity().checked_shl(1).unwrap_or(new_cap);
-
-                    new_cap = cmp::max(double, new_cap);
-
-                    // No space - allocate more
-                    //
-                    // The length field of `Shared::vec` is not used by the `BytesMut`;
-                    // instead we use the `len` field in the `BytesMut` itself. However,
-                    // when calling `reserve`, it doesn't guarantee that data stored in
-                    // the unused capacity of the vector is copied over to the new
-                    // allocation, so we need to ensure that we don't have any data we
-                    // care about in the unused capacity before calling `reserve`.
-                    debug_assert!(off + len <= v.capacity());
-                    v.set_len(off + len);
-                    v.reserve(new_cap - v.len());
-
-                    // Update the info
-                    self.ptr = vptr(v.as_mut_ptr().add(off));
-                    self.cap = v.capacity() - off;
-                }
-
-                return true;
-            }
-        }
-        if !allocate {
-            return false;
-        }
-
-        let original_capacity_repr = unsafe { (*shared).original_capacity_repr };
-        let original_capacity = original_capacity_from_repr(original_capacity_repr);
-
-        new_cap = cmp::max(new_cap, original_capacity);
-
-        // Create a new vector to store the data
-        let mut v = ManuallyDrop::new(Vec::with_capacity(new_cap));
-
-        // Copy the bytes
-        v.extend_from_slice(self.as_ref());
-
-        // Release the shared handle. This must be done *after* the bytes are
-        // copied.
-        unsafe { release_shared(shared) };
-
-        // Update self
-        let data = (original_capacity_repr << ORIGINAL_CAPACITY_OFFSET) | KIND_VEC;
-        self.data = invalid_ptr(data);
-        self.ptr = vptr(v.as_mut_ptr());
-        self.cap = v.capacity();
-        debug_assert_eq!(self.len, v.len());
-        return true;
-    }
-
-    /// Attempts to cheaply reclaim already allocated capacity for at least `additional` more
-    /// bytes to be inserted into the given `BytesMut` and returns `true` if it succeeded.
-    ///
-    /// `try_reclaim` behaves exactly like `reserve`, except that it never allocates new storage
-    /// and returns a `bool` indicating whether it was successful in doing so:
-    ///
-    /// `try_reclaim` returns false under these conditions:
-    ///  - The spare capacity left is less than `additional` bytes AND
-    ///  - The existing allocation cannot be reclaimed cheaply or it was less than
-    ///    `additional` bytes in size
-    ///
-    /// Reclaiming the allocation cheaply is possible if the `BytesMut` has no outstanding
-    /// references through other `BytesMut`s or `Bytes` which point to the same underlying
-    /// storage.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut buf = BytesMut::with_capacity(64);
-    /// assert_eq!(true, buf.try_reclaim(64));
-    /// assert_eq!(64, buf.capacity());
-    ///
-    /// buf.extend_from_slice(b"abcd");
-    /// let mut split = buf.split();
-    /// assert_eq!(60, buf.capacity());
-    /// assert_eq!(4, split.capacity());
-    /// assert_eq!(false, split.try_reclaim(64));
-    /// assert_eq!(false, buf.try_reclaim(64));
-    /// // The split buffer is filled with "abcd"
-    /// assert_eq!(false, split.try_reclaim(4));
-    /// // buf is empty and has capacity for 60 bytes
-    /// assert_eq!(true, buf.try_reclaim(60));
-    ///
-    /// drop(buf);
-    /// assert_eq!(false, split.try_reclaim(64));
-    ///
-    /// split.clear();
-    /// assert_eq!(4, split.capacity());
-    /// assert_eq!(true, split.try_reclaim(64));
-    /// assert_eq!(64, split.capacity());
-    /// ```
-    // I tried splitting out try_reclaim_inner after the short circuits, but it was inlined
-    // regardless with Rust 1.78.0 so probably not worth it
-    #[inline]
-    #[must_use = "consider BytesMut::reserve if you need an infallible reservation"]
-    pub fn try_reclaim(&mut self, additional: usize) -> bool {
-        let len = self.len();
-        let rem = self.capacity() - len;
-
-        if additional <= rem {
-            // The handle can already store at least `additional` more bytes, so
-            // there is no further work needed to be done.
-            return true;
-        }
-
-        self.reserve_inner(additional, false)
-    }
-
-    /// Appends given bytes to this `BytesMut`.
-    ///
-    /// If this `BytesMut` object does not have enough capacity, it is resized
-    /// first.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut buf = BytesMut::with_capacity(0);
-    /// buf.extend_from_slice(b"aaabbb");
-    /// buf.extend_from_slice(b"cccddd");
-    ///
-    /// assert_eq!(b"aaabbbcccddd", &buf[..]);
-    /// ```
-    #[inline]
-    pub fn extend_from_slice(&mut self, extend: &[u8]) {
-        let cnt = extend.len();
-        self.reserve(cnt);
-
-        unsafe {
-            let dst = self.spare_capacity_mut();
-            // Reserved above
-            debug_assert!(dst.len() >= cnt);
-
-            ptr::copy_nonoverlapping(extend.as_ptr(), dst.as_mut_ptr().cast(), cnt);
-        }
-
-        unsafe {
-            self.advance_mut(cnt);
-        }
-    }
-
-    /// Absorbs a `BytesMut` that was previously split off.
-    ///
-    /// If the two `BytesMut` objects were previously contiguous and not mutated
-    /// in a way that causes re-allocation i.e., if `other` was created by
-    /// calling `split_off` on this `BytesMut`, then this is an `O(1)` operation
-    /// that just decreases a reference count and sets a few indices.
-    /// Otherwise this method degenerates to
-    /// `self.extend_from_slice(other.as_ref())`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// let mut buf = BytesMut::with_capacity(64);
-    /// buf.extend_from_slice(b"aaabbbcccddd");
-    ///
-    /// let split = buf.split_off(6);
-    /// assert_eq!(b"aaabbb", &buf[..]);
-    /// assert_eq!(b"cccddd", &split[..]);
-    ///
-    /// buf.unsplit(split);
-    /// assert_eq!(b"aaabbbcccddd", &buf[..]);
-    /// ```
-    pub fn unsplit(&mut self, other: BytesMut) {
-        if self.is_empty() {
-            *self = other;
-            return;
-        }
-
-        if let Err(other) = self.try_unsplit(other) {
-            self.extend_from_slice(other.as_ref());
-        }
-    }
-
-    // private
-
-    // For now, use a `Vec` to manage the memory for us, but we may want to
-    // change that in the future to some alternate allocator strategy.
-    //
-    // Thus, we don't expose an easy way to construct from a `Vec` since an
-    // internal change could make a simple pattern (`BytesMut::from(vec)`)
-    // suddenly a lot more expensive.
-    #[inline]
-    pub(crate) fn from_vec(vec: Vec<u8>) -> BytesMut {
-        let mut vec = ManuallyDrop::new(vec);
-        let ptr = vptr(vec.as_mut_ptr());
-        let len = vec.len();
-        let cap = vec.capacity();
-
-        let original_capacity_repr = original_capacity_to_repr(cap);
-        let data = (original_capacity_repr << ORIGINAL_CAPACITY_OFFSET) | KIND_VEC;
-
-        BytesMut {
-            ptr,
-            len,
-            cap,
-            data: invalid_ptr(data),
-        }
-    }
-
-    #[inline]
-    fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.ptr.as_ptr(), self.len) }
-    }
-
-    #[inline]
-    fn as_slice_mut(&mut self) -> &mut [u8] {
-        unsafe { slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len) }
-    }
-
-    /// Advance the buffer without bounds checking.
-    ///
-    /// # SAFETY
-    ///
-    /// The caller must ensure that `count` <= `self.cap`.
-    pub(crate) unsafe fn advance_unchecked(&mut self, count: usize) {
-        // Setting the start to 0 is a no-op, so return early if this is the
-        // case.
-        if count == 0 {
-            return;
-        }
-
-        debug_assert!(count <= self.cap, "internal: set_start out of bounds");
-
-        let kind = self.kind();
-
-        if kind == KIND_VEC {
-            // Setting the start when in vec representation is a little more
-            // complicated. First, we have to track how far ahead the
-            // "start" of the byte buffer from the beginning of the vec. We
-            // also have to ensure that we don't exceed the maximum shift.
-            let pos = self.get_vec_pos() + count;
-
-            if pos <= MAX_VEC_POS {
-                self.set_vec_pos(pos);
-            } else {
-                // The repr must be upgraded to ARC. This will never happen
-                // on 64 bit systems and will only happen on 32 bit systems
-                // when shifting past 134,217,727 bytes. As such, we don't
-                // worry too much about performance here.
-                self.promote_to_shared(/*ref_count = */ 1);
-            }
-        }
-
-        // Updating the start of the view is setting `ptr` to point to the
-        // new start and updating the `len` field to reflect the new length
-        // of the view.
-        self.ptr = vptr(self.ptr.as_ptr().add(count));
-        self.len = self.len.checked_sub(count).unwrap_or(0);
-        self.cap -= count;
-    }
-
-    fn try_unsplit(&mut self, other: BytesMut) -> Result<(), BytesMut> {
-        if other.capacity() == 0 {
-            return Ok(());
-        }
-
-        let ptr = unsafe { self.ptr.as_ptr().add(self.len) };
-        if ptr == other.ptr.as_ptr()
-            && self.kind() == KIND_ARC
-            && other.kind() == KIND_ARC
-            && self.data == other.data
-        {
-            // Contiguous blocks, just combine directly
-            self.len += other.len;
-            self.cap += other.cap;
-            Ok(())
-        } else {
-            Err(other)
-        }
-    }
-
-    #[inline]
-    fn kind(&self) -> usize {
-        self.data as usize & KIND_MASK
-    }
-
-    unsafe fn promote_to_shared(&mut self, ref_cnt: usize) {
-        debug_assert_eq!(self.kind(), KIND_VEC);
-        debug_assert!(ref_cnt == 1 || ref_cnt == 2);
-
-        let original_capacity_repr =
-            (self.data as usize & ORIGINAL_CAPACITY_MASK) >> ORIGINAL_CAPACITY_OFFSET;
-
-        // The vec offset cannot be concurrently mutated, so there
-        // should be no danger reading it.
-        let off = (self.data as usize) >> VEC_POS_OFFSET;
-
-        // First, allocate a new `Shared` instance containing the
-        // `Vec` fields. It's important to note that `ptr`, `len`,
-        // and `cap` cannot be mutated without having `&mut self`.
-        // This means that these fields will not be concurrently
-        // updated and since the buffer hasn't been promoted to an
-        // `Arc`, those three fields still are the components of the
-        // vector.
-        let shared = Box::new(Shared {
-            vec: rebuild_vec(self.ptr.as_ptr(), self.len, self.cap, off),
-            original_capacity_repr,
-            ref_count: AtomicUsize::new(ref_cnt),
-        });
-
-        let shared = Box::into_raw(shared);
-
-        // The pointer should be aligned, so this assert should
-        // always succeed.
-        debug_assert_eq!(shared as usize & KIND_MASK, KIND_ARC);
-
-        self.data = shared;
-    }
-
-    /// Makes an exact shallow clone of `self`.
-    ///
-    /// The kind of `self` doesn't matter, but this is unsafe
-    /// because the clone will have the same offsets. You must
-    /// be sure the returned value to the user doesn't allow
-    /// two views into the same range.
-    #[inline]
-    unsafe fn shallow_clone(&mut self) -> BytesMut {
-        if self.kind() == KIND_ARC {
-            increment_shared(self.data);
-            ptr::read(self)
-        } else {
-            self.promote_to_shared(/*ref_count = */ 2);
-            ptr::read(self)
-        }
-    }
-
-    #[inline]
-    unsafe fn get_vec_pos(&self) -> usize {
-        debug_assert_eq!(self.kind(), KIND_VEC);
-
-        self.data as usize >> VEC_POS_OFFSET
-    }
-
-    #[inline]
-    unsafe fn set_vec_pos(&mut self, pos: usize) {
-        debug_assert_eq!(self.kind(), KIND_VEC);
-        debug_assert!(pos <= MAX_VEC_POS);
-
-        self.data = invalid_ptr((pos << VEC_POS_OFFSET) | (self.data as usize & NOT_VEC_POS_MASK));
-    }
-
-    /// Returns the remaining spare capacity of the buffer as a slice of `MaybeUninit<u8>`.
-    ///
-    /// The returned slice can be used to fill the buffer with data (e.g. by
-    /// reading from a file) before marking the data as initialized using the
-    /// [`set_len`] method.
-    ///
-    /// [`set_len`]: BytesMut::set_len
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BytesMut;
-    ///
-    /// // Allocate buffer big enough for 10 bytes.
-    /// let mut buf = BytesMut::with_capacity(10);
-    ///
-    /// // Fill in the first 3 elements.
-    /// let uninit = buf.spare_capacity_mut();
-    /// uninit[0].write(0);
-    /// uninit[1].write(1);
-    /// uninit[2].write(2);
-    ///
-    /// // Mark the first 3 bytes of the buffer as being initialized.
-    /// unsafe {
-    ///     buf.set_len(3);
-    /// }
-    ///
-    /// assert_eq!(&buf[..], &[0, 1, 2]);
-    /// ```
-    #[inline]
-    pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<u8>] {
-        unsafe {
-            let ptr = self.ptr.as_ptr().add(self.len);
-            let len = self.cap - self.len;
-
-            slice::from_raw_parts_mut(ptr.cast(), len)
-        }
-    }
-}
-
-impl Drop for BytesMut {
-    fn drop(&mut self) {
-        let kind = self.kind();
-
-        if kind == KIND_VEC {
-            unsafe {
-                let off = self.get_vec_pos();
-
-                // Vector storage, free the vector
-                let _ = rebuild_vec(self.ptr.as_ptr(), self.len, self.cap, off);
-            }
-        } else if kind == KIND_ARC {
-            unsafe { release_shared(self.data) };
-        }
-    }
-}
-
-impl Buf for BytesMut {
-    #[inline]
-    fn remaining(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk(&self) -> &[u8] {
-        self.as_slice()
-    }
-
-    #[inline]
-    fn advance(&mut self, cnt: usize) {
-        assert!(
-            cnt <= self.remaining(),
-            "cannot advance past `remaining`: {:?} <= {:?}",
-            cnt,
-            self.remaining(),
-        );
-        unsafe {
-            // SAFETY: We've checked that `cnt` <= `self.remaining()` and we know that
-            // `self.remaining()` <= `self.cap`.
-            self.advance_unchecked(cnt);
-        }
-    }
-
-    fn copy_to_bytes(&mut self, len: usize) -> Bytes {
-        self.split_to(len).freeze()
-    }
-}
-
-unsafe impl BufMut for BytesMut {
-    #[inline]
-    fn remaining_mut(&self) -> usize {
-        usize::MAX - self.len()
-    }
-
-    #[inline]
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        let remaining = self.cap - self.len();
-        if cnt > remaining {
-            super::panic_advance(&TryGetError {
-                requested: cnt,
-                available: remaining,
-            });
-        }
-        // Addition won't overflow since it is at most `self.cap`.
-        self.len = self.len() + cnt;
-    }
-
-    #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        if self.capacity() == self.len() {
-            self.reserve(64);
-        }
-        self.spare_capacity_mut().into()
-    }
-
-    // Specialize these methods so they can skip checking `remaining_mut`
-    // and `advance_mut`.
-
-    fn put<T: Buf>(&mut self, mut src: T)
-    where
-        Self: Sized,
-    {
-        while src.has_remaining() {
-            let s = src.chunk();
-            let l = s.len();
-            self.extend_from_slice(s);
-            src.advance(l);
-        }
-    }
-
-    fn put_slice(&mut self, src: &[u8]) {
-        self.extend_from_slice(src);
-    }
-
-    fn put_bytes(&mut self, val: u8, cnt: usize) {
-        self.reserve(cnt);
-        unsafe {
-            let dst = self.spare_capacity_mut();
-            // Reserved above
-            debug_assert!(dst.len() >= cnt);
-
-            ptr::write_bytes(dst.as_mut_ptr(), val, cnt);
-
-            self.advance_mut(cnt);
-        }
-    }
-}
-
-impl AsRef<[u8]> for BytesMut {
-    #[inline]
-    fn as_ref(&self) -> &[u8] {
-        self.as_slice()
-    }
-}
-
-impl Deref for BytesMut {
-    type Target = [u8];
-
-    #[inline]
-    fn deref(&self) -> &[u8] {
-        self.as_ref()
-    }
-}
-
-impl AsMut<[u8]> for BytesMut {
-    #[inline]
-    fn as_mut(&mut self) -> &mut [u8] {
-        self.as_slice_mut()
-    }
-}
-
-impl DerefMut for BytesMut {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut [u8] {
-        self.as_mut()
-    }
-}
-
-impl<'a> From<&'a [u8]> for BytesMut {
-    fn from(src: &'a [u8]) -> BytesMut {
-        BytesMut::from_vec(src.to_vec())
-    }
-}
-
-impl<'a> From<&'a str> for BytesMut {
-    fn from(src: &'a str) -> BytesMut {
-        BytesMut::from(src.as_bytes())
-    }
-}
-
-impl From<BytesMut> for Bytes {
-    fn from(src: BytesMut) -> Bytes {
-        src.freeze()
-    }
-}
-
-impl PartialEq for BytesMut {
-    fn eq(&self, other: &BytesMut) -> bool {
-        self.as_slice() == other.as_slice()
-    }
-}
-
-impl PartialOrd for BytesMut {
-    fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> {
-        self.as_slice().partial_cmp(other.as_slice())
-    }
-}
-
-impl Ord for BytesMut {
-    fn cmp(&self, other: &BytesMut) -> cmp::Ordering {
-        self.as_slice().cmp(other.as_slice())
-    }
-}
-
-impl Eq for BytesMut {}
-
-impl Default for BytesMut {
-    #[inline]
-    fn default() -> BytesMut {
-        BytesMut::new()
-    }
-}
-
-impl hash::Hash for BytesMut {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: hash::Hasher,
-    {
-        let s: &[u8] = self.as_ref();
-        s.hash(state);
-    }
-}
-
-impl Borrow<[u8]> for BytesMut {
-    fn borrow(&self) -> &[u8] {
-        self.as_ref()
-    }
-}
-
-impl BorrowMut<[u8]> for BytesMut {
-    fn borrow_mut(&mut self) -> &mut [u8] {
-        self.as_mut()
-    }
-}
-
-impl fmt::Write for BytesMut {
-    #[inline]
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        if self.remaining_mut() >= s.len() {
-            self.put_slice(s.as_bytes());
-            Ok(())
-        } else {
-            Err(fmt::Error)
-        }
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
-        fmt::write(self, args)
-    }
-}
-
-impl Clone for BytesMut {
-    fn clone(&self) -> BytesMut {
-        BytesMut::from(&self[..])
-    }
-}
-
-impl IntoIterator for BytesMut {
-    type Item = u8;
-    type IntoIter = IntoIter<BytesMut>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter::new(self)
-    }
-}
-
-impl<'a> IntoIterator for &'a BytesMut {
-    type Item = &'a u8;
-    type IntoIter = core::slice::Iter<'a, u8>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.as_ref().iter()
-    }
-}
-
-impl Extend<u8> for BytesMut {
-    fn extend<T>(&mut self, iter: T)
-    where
-        T: IntoIterator<Item = u8>,
-    {
-        let iter = iter.into_iter();
-
-        let (lower, _) = iter.size_hint();
-        self.reserve(lower);
-
-        // TODO: optimize
-        // 1. If self.kind() == KIND_VEC, use Vec::extend
-        for b in iter {
-            self.put_u8(b);
-        }
-    }
-}
-
-impl<'a> Extend<&'a u8> for BytesMut {
-    fn extend<T>(&mut self, iter: T)
-    where
-        T: IntoIterator<Item = &'a u8>,
-    {
-        self.extend(iter.into_iter().copied())
-    }
-}
-
-impl Extend<Bytes> for BytesMut {
-    fn extend<T>(&mut self, iter: T)
-    where
-        T: IntoIterator<Item = Bytes>,
-    {
-        for bytes in iter {
-            self.extend_from_slice(&bytes)
-        }
-    }
-}
-
-impl FromIterator<u8> for BytesMut {
-    fn from_iter<T: IntoIterator<Item = u8>>(into_iter: T) -> Self {
-        BytesMut::from_vec(Vec::from_iter(into_iter))
-    }
-}
-
-impl<'a> FromIterator<&'a u8> for BytesMut {
-    fn from_iter<T: IntoIterator<Item = &'a u8>>(into_iter: T) -> Self {
-        BytesMut::from_iter(into_iter.into_iter().copied())
-    }
-}
-
-/*
- *
- * ===== Inner =====
- *
- */
-
-unsafe fn increment_shared(ptr: *mut Shared) {
-    let old_size = (*ptr).ref_count.fetch_add(1, Ordering::Relaxed);
-
-    if old_size > isize::MAX as usize {
-        crate::abort();
-    }
-}
-
-unsafe fn release_shared(ptr: *mut Shared) {
-    // `Shared` storage... follow the drop steps from Arc.
-    if (*ptr).ref_count.fetch_sub(1, Ordering::Release) != 1 {
-        return;
-    }
-
-    // This fence is needed to prevent reordering of use of the data and
-    // deletion of the data.  Because it is marked `Release`, the decreasing
-    // of the reference count synchronizes with this `Acquire` fence. This
-    // means that use of the data happens before decreasing the reference
-    // count, which happens before this fence, which happens before the
-    // deletion of the data.
-    //
-    // As explained in the [Boost documentation][1],
-    //
-    // > It is important to enforce any possible access to the object in one
-    // > thread (through an existing reference) to *happen before* deleting
-    // > the object in a different thread. This is achieved by a "release"
-    // > operation after dropping a reference (any access to the object
-    // > through this reference must obviously happened before), and an
-    // > "acquire" operation before deleting the object.
-    //
-    // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
-    //
-    // Thread sanitizer does not support atomic fences. Use an atomic load
-    // instead.
-    (*ptr).ref_count.load(Ordering::Acquire);
-
-    // Drop the data
-    drop(Box::from_raw(ptr));
-}
-
-impl Shared {
-    fn is_unique(&self) -> bool {
-        // The goal is to check if the current handle is the only handle
-        // that currently has access to the buffer. This is done by
-        // checking if the `ref_count` is currently 1.
-        //
-        // The `Acquire` ordering synchronizes with the `Release` as
-        // part of the `fetch_sub` in `release_shared`. The `fetch_sub`
-        // operation guarantees that any mutations done in other threads
-        // are ordered before the `ref_count` is decremented. As such,
-        // this `Acquire` will guarantee that those mutations are
-        // visible to the current thread.
-        self.ref_count.load(Ordering::Acquire) == 1
-    }
-}
-
-#[inline]
-fn original_capacity_to_repr(cap: usize) -> usize {
-    let width = PTR_WIDTH - ((cap >> MIN_ORIGINAL_CAPACITY_WIDTH).leading_zeros() as usize);
-    cmp::min(
-        width,
-        MAX_ORIGINAL_CAPACITY_WIDTH - MIN_ORIGINAL_CAPACITY_WIDTH,
-    )
-}
-
-fn original_capacity_from_repr(repr: usize) -> usize {
-    if repr == 0 {
-        return 0;
-    }
-
-    1 << (repr + (MIN_ORIGINAL_CAPACITY_WIDTH - 1))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_original_capacity_to_repr() {
-        assert_eq!(original_capacity_to_repr(0), 0);
-
-        let max_width = 32;
-
-        for width in 1..(max_width + 1) {
-            let cap = 1 << width - 1;
-
-            let expected = if width < MIN_ORIGINAL_CAPACITY_WIDTH {
-                0
-            } else if width < MAX_ORIGINAL_CAPACITY_WIDTH {
-                width - MIN_ORIGINAL_CAPACITY_WIDTH
-            } else {
-                MAX_ORIGINAL_CAPACITY_WIDTH - MIN_ORIGINAL_CAPACITY_WIDTH
-            };
-
-            assert_eq!(original_capacity_to_repr(cap), expected);
-
-            if width > 1 {
-                assert_eq!(original_capacity_to_repr(cap + 1), expected);
-            }
-
-            //  MIN_ORIGINAL_CAPACITY_WIDTH must be bigger than 7 to pass tests below
-            if width == MIN_ORIGINAL_CAPACITY_WIDTH + 1 {
-                assert_eq!(original_capacity_to_repr(cap - 24), expected - 1);
-                assert_eq!(original_capacity_to_repr(cap + 76), expected);
-            } else if width == MIN_ORIGINAL_CAPACITY_WIDTH + 2 {
-                assert_eq!(original_capacity_to_repr(cap - 1), expected - 1);
-                assert_eq!(original_capacity_to_repr(cap - 48), expected - 1);
-            }
-        }
-    }
-
-    #[test]
-    fn test_original_capacity_from_repr() {
-        assert_eq!(0, original_capacity_from_repr(0));
-
-        let min_cap = 1 << MIN_ORIGINAL_CAPACITY_WIDTH;
-
-        assert_eq!(min_cap, original_capacity_from_repr(1));
-        assert_eq!(min_cap * 2, original_capacity_from_repr(2));
-        assert_eq!(min_cap * 4, original_capacity_from_repr(3));
-        assert_eq!(min_cap * 8, original_capacity_from_repr(4));
-        assert_eq!(min_cap * 16, original_capacity_from_repr(5));
-        assert_eq!(min_cap * 32, original_capacity_from_repr(6));
-        assert_eq!(min_cap * 64, original_capacity_from_repr(7));
-    }
-}
-
-unsafe impl Send for BytesMut {}
-unsafe impl Sync for BytesMut {}
-
-/*
- *
- * ===== PartialEq / PartialOrd =====
- *
- */
-
-impl PartialEq<[u8]> for BytesMut {
-    fn eq(&self, other: &[u8]) -> bool {
-        &**self == other
-    }
-}
-
-impl PartialOrd<[u8]> for BytesMut {
-    fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
-        (**self).partial_cmp(other)
-    }
-}
-
-impl PartialEq<BytesMut> for [u8] {
-    fn eq(&self, other: &BytesMut) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<BytesMut> for [u8] {
-    fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other)
-    }
-}
-
-impl PartialEq<str> for BytesMut {
-    fn eq(&self, other: &str) -> bool {
-        &**self == other.as_bytes()
-    }
-}
-
-impl PartialOrd<str> for BytesMut {
-    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
-        (**self).partial_cmp(other.as_bytes())
-    }
-}
-
-impl PartialEq<BytesMut> for str {
-    fn eq(&self, other: &BytesMut) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<BytesMut> for str {
-    fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other)
-    }
-}
-
-impl PartialEq<Vec<u8>> for BytesMut {
-    fn eq(&self, other: &Vec<u8>) -> bool {
-        *self == other[..]
-    }
-}
-
-impl PartialOrd<Vec<u8>> for BytesMut {
-    fn partial_cmp(&self, other: &Vec<u8>) -> Option<cmp::Ordering> {
-        (**self).partial_cmp(&other[..])
-    }
-}
-
-impl PartialEq<BytesMut> for Vec<u8> {
-    fn eq(&self, other: &BytesMut) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<BytesMut> for Vec<u8> {
-    fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> {
-        other.partial_cmp(self)
-    }
-}
-
-impl PartialEq<String> for BytesMut {
-    fn eq(&self, other: &String) -> bool {
-        *self == other[..]
-    }
-}
-
-impl PartialOrd<String> for BytesMut {
-    fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
-        (**self).partial_cmp(other.as_bytes())
-    }
-}
-
-impl PartialEq<BytesMut> for String {
-    fn eq(&self, other: &BytesMut) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<BytesMut> for String {
-    fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other)
-    }
-}
-
-impl<'a, T: ?Sized> PartialEq<&'a T> for BytesMut
-where
-    BytesMut: PartialEq<T>,
-{
-    fn eq(&self, other: &&'a T) -> bool {
-        *self == **other
-    }
-}
-
-impl<'a, T: ?Sized> PartialOrd<&'a T> for BytesMut
-where
-    BytesMut: PartialOrd<T>,
-{
-    fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> {
-        self.partial_cmp(*other)
-    }
-}
-
-impl PartialEq<BytesMut> for &[u8] {
-    fn eq(&self, other: &BytesMut) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<BytesMut> for &[u8] {
-    fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> {
-        <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other)
-    }
-}
-
-impl PartialEq<BytesMut> for &str {
-    fn eq(&self, other: &BytesMut) -> bool {
-        *other == *self
-    }
-}
-
-impl PartialOrd<BytesMut> for &str {
-    fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> {
-        other.partial_cmp(self)
-    }
-}
-
-impl PartialEq<BytesMut> for Bytes {
-    fn eq(&self, other: &BytesMut) -> bool {
-        other[..] == self[..]
-    }
-}
-
-impl PartialEq<Bytes> for BytesMut {
-    fn eq(&self, other: &Bytes) -> bool {
-        other[..] == self[..]
-    }
-}
-
-impl From<BytesMut> for Vec<u8> {
-    fn from(bytes: BytesMut) -> Self {
-        let kind = bytes.kind();
-        let bytes = ManuallyDrop::new(bytes);
-
-        let mut vec = if kind == KIND_VEC {
-            unsafe {
-                let off = bytes.get_vec_pos();
-                rebuild_vec(bytes.ptr.as_ptr(), bytes.len, bytes.cap, off)
-            }
-        } else {
-            let shared = bytes.data as *mut Shared;
-
-            if unsafe { (*shared).is_unique() } {
-                let vec = mem::replace(unsafe { &mut (*shared).vec }, Vec::new());
-
-                unsafe { release_shared(shared) };
-
-                vec
-            } else {
-                return ManuallyDrop::into_inner(bytes).deref().to_vec();
-            }
-        };
-
-        let len = bytes.len;
-
-        unsafe {
-            ptr::copy(bytes.ptr.as_ptr(), vec.as_mut_ptr(), len);
-            vec.set_len(len);
-        }
-
-        vec
-    }
-}
-
-#[inline]
-fn vptr(ptr: *mut u8) -> NonNull<u8> {
-    if cfg!(debug_assertions) {
-        NonNull::new(ptr).expect("Vec pointer should be non-null")
-    } else {
-        unsafe { NonNull::new_unchecked(ptr) }
-    }
-}
-
-/// Returns a dangling pointer with the given address. This is used to store
-/// integer data in pointer fields.
-///
-/// It is equivalent to `addr as *mut T`, but this fails on miri when strict
-/// provenance checking is enabled.
-#[inline]
-fn invalid_ptr<T>(addr: usize) -> *mut T {
-    let ptr = core::ptr::null_mut::<u8>().wrapping_add(addr);
-    debug_assert_eq!(ptr as usize, addr);
-    ptr.cast::<T>()
-}
-
-unsafe fn rebuild_vec(ptr: *mut u8, mut len: usize, mut cap: usize, off: usize) -> Vec<u8> {
-    let ptr = ptr.sub(off);
-    len += off;
-    cap += off;
-
-    Vec::from_raw_parts(ptr, len, cap)
-}
-
-// ===== impl SharedVtable =====
-
-static SHARED_VTABLE: Vtable = Vtable {
-    clone: shared_v_clone,
-    to_vec: shared_v_to_vec,
-    to_mut: shared_v_to_mut,
-    is_unique: shared_v_is_unique,
-    drop: shared_v_drop,
-};
-
-unsafe fn shared_v_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
-    let shared = data.load(Ordering::Relaxed) as *mut Shared;
-    increment_shared(shared);
-
-    let data = AtomicPtr::new(shared as *mut ());
-    Bytes::with_vtable(ptr, len, data, &SHARED_VTABLE)
-}
-
-unsafe fn shared_v_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    let shared: *mut Shared = data.load(Ordering::Relaxed).cast();
-
-    if (*shared).is_unique() {
-        let shared = &mut *shared;
-
-        // Drop shared
-        let mut vec = mem::replace(&mut shared.vec, Vec::new());
-        release_shared(shared);
-
-        // Copy back buffer
-        ptr::copy(ptr, vec.as_mut_ptr(), len);
-        vec.set_len(len);
-
-        vec
-    } else {
-        let v = slice::from_raw_parts(ptr, len).to_vec();
-        release_shared(shared);
-        v
-    }
-}
-
-unsafe fn shared_v_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
-    let shared: *mut Shared = data.load(Ordering::Relaxed).cast();
-
-    if (*shared).is_unique() {
-        let shared = &mut *shared;
-
-        // The capacity is always the original capacity of the buffer
-        // minus the offset from the start of the buffer
-        let v = &mut shared.vec;
-        let v_capacity = v.capacity();
-        let v_ptr = v.as_mut_ptr();
-        let offset = offset_from(ptr as *mut u8, v_ptr);
-        let cap = v_capacity - offset;
-
-        let ptr = vptr(ptr as *mut u8);
-
-        BytesMut {
-            ptr,
-            len,
-            cap,
-            data: shared,
-        }
-    } else {
-        let v = slice::from_raw_parts(ptr, len).to_vec();
-        release_shared(shared);
-        BytesMut::from_vec(v)
-    }
-}
-
-unsafe fn shared_v_is_unique(data: &AtomicPtr<()>) -> bool {
-    let shared = data.load(Ordering::Acquire);
-    let ref_count = (*shared.cast::<Shared>()).ref_count.load(Ordering::Relaxed);
-    ref_count == 1
-}
-
-unsafe fn shared_v_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) {
-    data.with_mut(|shared| {
-        release_shared(*shared as *mut Shared);
-    });
-}
-
-// compile-fails
-
-/// ```compile_fail
-/// use bytes::BytesMut;
-/// #[deny(unused_must_use)]
-/// {
-///     let mut b1 = BytesMut::from("hello world");
-///     b1.split_to(6);
-/// }
-/// ```
-fn _split_to_must_use() {}
-
-/// ```compile_fail
-/// use bytes::BytesMut;
-/// #[deny(unused_must_use)]
-/// {
-///     let mut b1 = BytesMut::from("hello world");
-///     b1.split_off(6);
-/// }
-/// ```
-fn _split_off_must_use() {}
-
-/// ```compile_fail
-/// use bytes::BytesMut;
-/// #[deny(unused_must_use)]
-/// {
-///     let mut b1 = BytesMut::from("hello world");
-///     b1.split();
-/// }
-/// ```
-fn _split_must_use() {}
-
-// fuzz tests
-#[cfg(all(test, loom))]
-mod fuzz {
-    use loom::sync::Arc;
-    use loom::thread;
-
-    use super::BytesMut;
-    use crate::Bytes;
-
-    #[test]
-    fn bytes_mut_cloning_frozen() {
-        loom::model(|| {
-            let a = BytesMut::from(&b"abcdefgh"[..]).split().freeze();
-            let addr = a.as_ptr() as usize;
-
-            // test the Bytes::clone is Sync by putting it in an Arc
-            let a1 = Arc::new(a);
-            let a2 = a1.clone();
-
-            let t1 = thread::spawn(move || {
-                let b: Bytes = (*a1).clone();
-                assert_eq!(b.as_ptr() as usize, addr);
-            });
-
-            let t2 = thread::spawn(move || {
-                let b: Bytes = (*a2).clone();
-                assert_eq!(b.as_ptr() as usize, addr);
-            });
-
-            t1.join().unwrap();
-            t2.join().unwrap();
-        });
-    }
-}
diff --git a/vendor/bytes/src/fmt/debug.rs b/vendor/bytes/src/fmt/debug.rs
deleted file mode 100644
index 82d0aa5e..00000000
--- a/vendor/bytes/src/fmt/debug.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use core::fmt::{Debug, Formatter, Result};
-
-use super::BytesRef;
-use crate::{Bytes, BytesMut};
-
-/// Alternative implementation of `std::fmt::Debug` for byte slice.
-///
-/// Standard `Debug` implementation for `[u8]` is comma separated
-/// list of numbers. Since large amount of byte strings are in fact
-/// ASCII strings or contain a lot of ASCII strings (e. g. HTTP),
-/// it is convenient to print strings as ASCII when possible.
-impl Debug for BytesRef<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        write!(f, "b\"")?;
-        for &b in self.0 {
-            // https://doc.rust-lang.org/reference/tokens.html#byte-escapes
-            if b == b'\n' {
-                write!(f, "\\n")?;
-            } else if b == b'\r' {
-                write!(f, "\\r")?;
-            } else if b == b'\t' {
-                write!(f, "\\t")?;
-            } else if b == b'\\' || b == b'"' {
-                write!(f, "\\{}", b as char)?;
-            } else if b == b'\0' {
-                write!(f, "\\0")?;
-            // ASCII printable
-            } else if (0x20..0x7f).contains(&b) {
-                write!(f, "{}", b as char)?;
-            } else {
-                write!(f, "\\x{:02x}", b)?;
-            }
-        }
-        write!(f, "\"")?;
-        Ok(())
-    }
-}
-
-fmt_impl!(Debug, Bytes);
-fmt_impl!(Debug, BytesMut);
diff --git a/vendor/bytes/src/fmt/hex.rs b/vendor/bytes/src/fmt/hex.rs
deleted file mode 100644
index 1203b419..00000000
--- a/vendor/bytes/src/fmt/hex.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use core::fmt::{Formatter, LowerHex, Result, UpperHex};
-
-use super::BytesRef;
-use crate::{Bytes, BytesMut};
-
-impl LowerHex for BytesRef<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        for &b in self.0 {
-            write!(f, "{:02x}", b)?;
-        }
-        Ok(())
-    }
-}
-
-impl UpperHex for BytesRef<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        for &b in self.0 {
-            write!(f, "{:02X}", b)?;
-        }
-        Ok(())
-    }
-}
-
-fmt_impl!(LowerHex, Bytes);
-fmt_impl!(LowerHex, BytesMut);
-fmt_impl!(UpperHex, Bytes);
-fmt_impl!(UpperHex, BytesMut);
diff --git a/vendor/bytes/src/fmt/mod.rs b/vendor/bytes/src/fmt/mod.rs
deleted file mode 100644
index b8a0eafa..00000000
--- a/vendor/bytes/src/fmt/mod.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-macro_rules! fmt_impl {
-    ($tr:ident, $ty:ty) => {
-        impl $tr for $ty {
-            fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-                $tr::fmt(&BytesRef(self.as_ref()), f)
-            }
-        }
-    };
-}
-
-mod debug;
-mod hex;
-
-/// `BytesRef` is not a part of public API of bytes crate.
-struct BytesRef<'a>(&'a [u8]);
diff --git a/vendor/bytes/src/lib.rs b/vendor/bytes/src/lib.rs
deleted file mode 100644
index 08c42494..00000000
--- a/vendor/bytes/src/lib.rs
+++ /dev/null
@@ -1,199 +0,0 @@
-#![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
-#![doc(test(
-    no_crate_inject,
-    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
-))]
-#![no_std]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-
-//! Provides abstractions for working with bytes.
-//!
-//! The `bytes` crate provides an efficient byte buffer structure
-//! ([`Bytes`]) and traits for working with buffer
-//! implementations ([`Buf`], [`BufMut`]).
-//!
-//! # `Bytes`
-//!
-//! `Bytes` is an efficient container for storing and operating on contiguous
-//! slices of memory. It is intended for use primarily in networking code, but
-//! could have applications elsewhere as well.
-//!
-//! `Bytes` values facilitate zero-copy network programming by allowing multiple
-//! `Bytes` objects to point to the same underlying memory. This is managed by
-//! using a reference count to track when the memory is no longer needed and can
-//! be freed.
-//!
-//! A `Bytes` handle can be created directly from an existing byte store (such as `&[u8]`
-//! or `Vec<u8>`), but usually a `BytesMut` is used first and written to. For
-//! example:
-//!
-//! ```rust
-//! use bytes::{BytesMut, BufMut};
-//!
-//! let mut buf = BytesMut::with_capacity(1024);
-//! buf.put(&b"hello world"[..]);
-//! buf.put_u16(1234);
-//!
-//! let a = buf.split();
-//! assert_eq!(a, b"hello world\x04\xD2"[..]);
-//!
-//! buf.put(&b"goodbye world"[..]);
-//!
-//! let b = buf.split();
-//! assert_eq!(b, b"goodbye world"[..]);
-//!
-//! assert_eq!(buf.capacity(), 998);
-//! ```
-//!
-//! In the above example, only a single buffer of 1024 is allocated. The handles
-//! `a` and `b` will share the underlying buffer and maintain indices tracking
-//! the view into the buffer represented by the handle.
-//!
-//! See the [struct docs](`Bytes`) for more details.
-//!
-//! # `Buf`, `BufMut`
-//!
-//! These two traits provide read and write access to buffers. The underlying
-//! storage may or may not be in contiguous memory. For example, `Bytes` is a
-//! buffer that guarantees contiguous memory, but a [rope] stores the bytes in
-//! disjoint chunks. `Buf` and `BufMut` maintain cursors tracking the current
-//! position in the underlying byte storage. When bytes are read or written, the
-//! cursor is advanced.
-//!
-//! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure)
-//!
-//! ## Relation with `Read` and `Write`
-//!
-//! At first glance, it may seem that `Buf` and `BufMut` overlap in
-//! functionality with [`std::io::Read`] and [`std::io::Write`]. However, they
-//! serve different purposes. A buffer is the value that is provided as an
-//! argument to `Read::read` and `Write::write`. `Read` and `Write` may then
-//! perform a syscall, which has the potential of failing. Operations on `Buf`
-//! and `BufMut` are infallible.
-
-extern crate alloc;
-
-#[cfg(feature = "std")]
-extern crate std;
-
-pub mod buf;
-pub use crate::buf::{Buf, BufMut};
-
-mod bytes;
-mod bytes_mut;
-mod fmt;
-mod loom;
-pub use crate::bytes::Bytes;
-pub use crate::bytes_mut::BytesMut;
-
-// Optional Serde support
-#[cfg(feature = "serde")]
-mod serde;
-
-#[inline(never)]
-#[cold]
-fn abort() -> ! {
-    #[cfg(feature = "std")]
-    {
-        std::process::abort();
-    }
-
-    #[cfg(not(feature = "std"))]
-    {
-        struct Abort;
-        impl Drop for Abort {
-            fn drop(&mut self) {
-                panic!();
-            }
-        }
-        let _a = Abort;
-        panic!("abort");
-    }
-}
-
-#[inline(always)]
-#[cfg(feature = "std")]
-fn saturating_sub_usize_u64(a: usize, b: u64) -> usize {
-    use core::convert::TryFrom;
-    match usize::try_from(b) {
-        Ok(b) => a.saturating_sub(b),
-        Err(_) => 0,
-    }
-}
-
-#[inline(always)]
-#[cfg(feature = "std")]
-fn min_u64_usize(a: u64, b: usize) -> usize {
-    use core::convert::TryFrom;
-    match usize::try_from(a) {
-        Ok(a) => usize::min(a, b),
-        Err(_) => b,
-    }
-}
-
-/// Error type for the `try_get_` methods of [`Buf`].
-/// Indicates that there were not enough remaining
-/// bytes in the buffer while attempting
-/// to get a value from a [`Buf`] with one
-/// of the `try_get_` methods.
-#[derive(Debug, PartialEq, Eq)]
-pub struct TryGetError {
-    /// The number of bytes necessary to get the value
-    pub requested: usize,
-
-    /// The number of bytes available in the buffer
-    pub available: usize,
-}
-
-impl core::fmt::Display for TryGetError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
-        write!(
-            f,
-            "Not enough bytes remaining in buffer to read value (requested {} but only {} available)",
-            self.requested,
-            self.available
-        )
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for TryGetError {}
-
-#[cfg(feature = "std")]
-impl From<TryGetError> for std::io::Error {
-    fn from(error: TryGetError) -> Self {
-        std::io::Error::new(std::io::ErrorKind::Other, error)
-    }
-}
-
-/// Panic with a nice error message.
-#[cold]
-fn panic_advance(error_info: &TryGetError) -> ! {
-    panic!(
-        "advance out of bounds: the len is {} but advancing by {}",
-        error_info.available, error_info.requested
-    );
-}
-
-#[cold]
-fn panic_does_not_fit(size: usize, nbytes: usize) -> ! {
-    panic!(
-        "size too large: the integer type can fit {} bytes, but nbytes is {}",
-        size, nbytes
-    );
-}
-
-/// Precondition: dst >= original
-///
-/// The following line is equivalent to:
-///
-/// ```rust,ignore
-/// self.ptr.as_ptr().offset_from(ptr) as usize;
-/// ```
-///
-/// But due to min rust is 1.39 and it is only stabilized
-/// in 1.47, we cannot use it.
-#[inline]
-fn offset_from(dst: *const u8, original: *const u8) -> usize {
-    dst as usize - original as usize
-}
diff --git a/vendor/bytes/src/loom.rs b/vendor/bytes/src/loom.rs
deleted file mode 100644
index c8092909..00000000
--- a/vendor/bytes/src/loom.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#[cfg(not(all(test, loom)))]
-pub(crate) mod sync {
-    pub(crate) mod atomic {
-        #[cfg(not(feature = "extra-platforms"))]
-        pub(crate) use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
-        #[cfg(feature = "extra-platforms")]
-        pub(crate) use extra_platforms::{AtomicPtr, AtomicUsize, Ordering};
-
-        pub(crate) trait AtomicMut<T> {
-            fn with_mut<F, R>(&mut self, f: F) -> R
-            where
-                F: FnOnce(&mut *mut T) -> R;
-        }
-
-        impl<T> AtomicMut<T> for AtomicPtr<T> {
-            fn with_mut<F, R>(&mut self, f: F) -> R
-            where
-                F: FnOnce(&mut *mut T) -> R,
-            {
-                f(self.get_mut())
-            }
-        }
-    }
-}
-
-#[cfg(all(test, loom))]
-pub(crate) mod sync {
-    pub(crate) mod atomic {
-        pub(crate) use loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
-
-        pub(crate) trait AtomicMut<T> {}
-    }
-}
diff --git a/vendor/bytes/src/serde.rs b/vendor/bytes/src/serde.rs
deleted file mode 100644
index 0a5bd144..00000000
--- a/vendor/bytes/src/serde.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use super::{Bytes, BytesMut};
-use alloc::string::String;
-use alloc::vec::Vec;
-use core::{cmp, fmt};
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-
-macro_rules! serde_impl {
-    ($ty:ident, $visitor_ty:ident, $from_slice:ident, $from_vec:ident) => {
-        impl Serialize for $ty {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.serialize_bytes(&self)
-            }
-        }
-
-        struct $visitor_ty;
-
-        impl<'de> de::Visitor<'de> for $visitor_ty {
-            type Value = $ty;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("byte array")
-            }
-
-            #[inline]
-            fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
-            where
-                V: de::SeqAccess<'de>,
-            {
-                let len = cmp::min(seq.size_hint().unwrap_or(0), 4096);
-                let mut values: Vec<u8> = Vec::with_capacity(len);
-
-                while let Some(value) = seq.next_element()? {
-                    values.push(value);
-                }
-
-                Ok($ty::$from_vec(values))
-            }
-
-            #[inline]
-            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-            where
-                E: de::Error,
-            {
-                Ok($ty::$from_slice(v))
-            }
-
-            #[inline]
-            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-            where
-                E: de::Error,
-            {
-                Ok($ty::$from_vec(v))
-            }
-
-            #[inline]
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
-                E: de::Error,
-            {
-                Ok($ty::$from_slice(v.as_bytes()))
-            }
-
-            #[inline]
-            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-            where
-                E: de::Error,
-            {
-                Ok($ty::$from_vec(v.into_bytes()))
-            }
-        }
-
-        impl<'de> Deserialize<'de> for $ty {
-            #[inline]
-            fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                deserializer.deserialize_byte_buf($visitor_ty)
-            }
-        }
-    };
-}
-
-serde_impl!(Bytes, BytesVisitor, copy_from_slice, from);
-serde_impl!(BytesMut, BytesMutVisitor, from, from_vec);