serde_core/
lib.rs

1//! Serde is a framework for ***ser***ializing and ***de***serializing Rust data
2//! structures efficiently and generically.
3//!
4//! The `serde_core` crate contains Serde's trait definitions with **no support
5//! for #\[derive()\]**.
6//!
7//! In crates that derive an implementation of `Serialize` or `Deserialize`, you
8//! must depend on the [`serde`] crate, not `serde_core`.
9//!
10//! [`serde`]: https://crates.io/crates/serde
11//!
12//! In crates that handwrite implementations of Serde traits, or only use them
13//! as trait bounds, depending on `serde_core` is permitted. But `serde`
14//! re-exports all of these traits and can be used for this use case too. If in
15//! doubt, disregard `serde_core` and always use `serde`.
16//!
17//! Crates that depend on `serde_core` instead of `serde` are able to compile in
18//! parallel with `serde_derive` even when `serde`'s "derive" feature is turned on,
19//! as shown in the following build timings.
20//!
21//! <br>
22//!
23//! <table>
24//! <tr><td align="center">When <code>serde_json</code> depends on <code>serde</code></td></tr>
25//! <tr><td><img src="https://github.com/user-attachments/assets/78dc179c-6ab1-4059-928c-1474b0d9d0bb"></td></tr>
26//! </table>
27//!
28//! <br>
29//!
30//! <table>
31//! <tr><td align="center">When <code>serde_json</code> depends on <code>serde_core</code></td></tr>
32//! <tr><td><img src="https://github.com/user-attachments/assets/6b6cff5e-3e45-4ac7-9db1-d99ee8b9f5f7"></td></tr>
33//! </table>
34
35////////////////////////////////////////////////////////////////////////////////
36
37// Serde types in rustdoc of other crates get linked to here.
38#![doc(html_root_url = "https://docs.rs/serde_core/1.0.228")]
39// Support using Serde without the standard library!
40#![cfg_attr(not(feature = "std"), no_std)]
41// Show which crate feature enables conditionally compiled APIs in documentation.
42#![cfg_attr(docsrs, feature(doc_cfg, rustdoc_internals))]
43#![cfg_attr(docsrs, allow(internal_features))]
44// Unstable functionality only if the user asks for it. For tracking and
45// discussion of these features please refer to this issue:
46//
47//    https://github.com/serde-rs/serde/issues/812
48#![cfg_attr(feature = "unstable", feature(never_type))]
49#![allow(unknown_lints, bare_trait_objects, deprecated)]
50// Ignored clippy and clippy_pedantic lints
51#![allow(
52    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
53    clippy::unnested_or_patterns,
54    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
55    clippy::semicolon_if_nothing_returned,
56    // not available in our oldest supported compiler
57    clippy::empty_enum,
58    clippy::type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
59    // integer and float ser/de requires these sorts of casts
60    clippy::cast_possible_truncation,
61    clippy::cast_possible_wrap,
62    clippy::cast_precision_loss,
63    clippy::cast_sign_loss,
64    // things are often more readable this way
65    clippy::cast_lossless,
66    clippy::module_name_repetitions,
67    clippy::single_match_else,
68    clippy::type_complexity,
69    clippy::use_self,
70    clippy::zero_prefixed_literal,
71    // correctly used
72    clippy::derive_partial_eq_without_eq,
73    clippy::enum_glob_use,
74    clippy::explicit_auto_deref,
75    clippy::incompatible_msrv,
76    clippy::let_underscore_untyped,
77    clippy::map_err_ignore,
78    clippy::new_without_default,
79    clippy::result_unit_err,
80    clippy::wildcard_imports,
81    // not practical
82    clippy::needless_pass_by_value,
83    clippy::similar_names,
84    clippy::too_many_lines,
85    // preference
86    clippy::doc_markdown,
87    clippy::elidable_lifetime_names,
88    clippy::needless_lifetimes,
89    clippy::unseparated_literal_suffix,
90    // false positive
91    clippy::needless_doctest_main,
92    // noisy
93    clippy::missing_errors_doc,
94    clippy::must_use_candidate,
95)]
96// Restrictions
97#![deny(clippy::question_mark_used)]
98// Rustc lints.
99#![deny(missing_docs, unused_imports)]
100
101////////////////////////////////////////////////////////////////////////////////
102
103#[cfg(feature = "alloc")]
104extern crate alloc;
105
106#[macro_use]
107mod crate_root;
108#[macro_use]
109mod macros;
110
111/// A facade around all the types we need from the `std`, `core`, and `alloc`
/// crates. This avoids elaborate import wrangling having to happen in every
/// module.
mod lib {
    mod core {
        pub use std::*;
    }
    pub use self::core::{f32, f64};
    pub use self::core::{iter, num, str};
    pub use self::core::{cmp, mem};
    pub use self::core::cell::{Cell, RefCell};
    pub use self::core::cmp::Reverse;
    pub use self::core::fmt::{self, Debug, Display, Write as FmtWrite};
    pub use self::core::marker::PhantomData;
    pub use self::core::num::Wrapping;
    pub use self::core::ops::{
        Bound, Range, RangeFrom, RangeInclusive, RangeTo,
    };
    pub use self::core::result;
    pub use self::core::time::Duration;
    pub use std::borrow::{Cow, ToOwned};
    pub use std::string::{String, ToString};
    pub use std::vec::Vec;
    pub use std::boxed::Box;
    pub use std::rc::{Rc, Weak as RcWeak};
    pub use std::sync::{Arc, Weak as ArcWeak};
    pub use std::collections::{
        BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque,
    };
    pub use std::ffi::CStr;
    pub use std::ffi::CString;
    pub use std::net;
    pub use std::error;
    pub use std::collections::{HashMap, HashSet};
    pub use std::ffi::{OsStr, OsString};
    pub use std::hash::{BuildHasher, Hash};
    pub use std::io::Write;
    pub use std::path::{Path, PathBuf};
    pub use std::sync::{Mutex, RwLock};
    pub use std::time::{SystemTime, UNIX_EPOCH};
    pub use std::sync::atomic::Ordering;
    pub use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};
    pub use std::sync::atomic::{AtomicI16, AtomicU16};
    pub use std::sync::atomic::{AtomicI32, AtomicU32};
    pub use std::sync::atomic::{AtomicI64, AtomicU64};
    pub use std::sync::atomic::{AtomicIsize, AtomicUsize};
    pub use self::core::num::Saturating;
}
macro_rules! tri {
    ($expr : expr) =>
    { match $expr { Ok(val) => val, Err(err) => return Err(err), } };
}
pub mod de {
    //! Generic data structure deserialization framework.
    //!
    //! The two most important traits in this module are [`Deserialize`] and
    //! [`Deserializer`].
    //!
    //!  - **A type that implements `Deserialize` is a data structure** that can be
    //!    deserialized from any data format supported by Serde, and conversely
    //!  - **A type that implements `Deserializer` is a data format** that can
    //!    deserialize any data structure supported by Serde.
    //!
    //! # The Deserialize trait
    //!
    //! Serde provides [`Deserialize`] implementations for many Rust primitive and
    //! standard library types. The complete list is below. All of these can be
    //! deserialized using Serde out of the box.
    //!
    //! Additionally, Serde provides a procedural macro called [`serde_derive`] to
    //! automatically generate [`Deserialize`] implementations for structs and enums
    //! in your program. See the [derive section of the manual] for how to use this.
    //!
    //! In rare cases it may be necessary to implement [`Deserialize`] manually for
    //! some type in your program. See the [Implementing `Deserialize`] section of
    //! the manual for more about this.
    //!
    //! Third-party crates may provide [`Deserialize`] implementations for types
    //! that they expose. For example the [`linked-hash-map`] crate provides a
    //! [`LinkedHashMap<K, V>`] type that is deserializable by Serde because the
    //! crate provides an implementation of [`Deserialize`] for it.
    //!
    //! # The Deserializer trait
    //!
    //! [`Deserializer`] implementations are provided by third-party crates, for
    //! example [`serde_json`], [`serde_yaml`] and [`postcard`].
    //!
    //! A partial list of well-maintained formats is given on the [Serde
    //! website][data formats].
    //!
    //! # Implementations of Deserialize provided by Serde
    //!
    //! This is a slightly different set of types than what is supported for
    //! serialization. Some types can be serialized by Serde but not deserialized.
    //! One example is `OsStr`.
    //!
    //!  - **Primitive types**:
    //!    - bool
    //!    - i8, i16, i32, i64, i128, isize
    //!    - u8, u16, u32, u64, u128, usize
    //!    - f32, f64
    //!    - char
    //!  - **Compound types**:
    //!    - \[T; 0\] through \[T; 32\]
    //!    - tuples up to size 16
    //!  - **Common standard library types**:
    //!    - String
    //!    - Option\<T\>
    //!    - Result\<T, E\>
    //!    - PhantomData\<T\>
    //!  - **Wrapper types**:
    //!    - Box\<T\>
    //!    - Box\<\[T\]\>
    //!    - Box\<str\>
    //!    - Cow\<'a, T\>
    //!    - Cell\<T\>
    //!    - RefCell\<T\>
    //!    - Mutex\<T\>
    //!    - RwLock\<T\>
    //!    - Rc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
    //!    - Arc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
    //!  - **Collection types**:
    //!    - BTreeMap\<K, V\>
    //!    - BTreeSet\<T\>
    //!    - BinaryHeap\<T\>
    //!    - HashMap\<K, V, H\>
    //!    - HashSet\<T, H\>
    //!    - LinkedList\<T\>
    //!    - VecDeque\<T\>
    //!    - Vec\<T\>
    //!  - **Zero-copy types**:
    //!    - &str
    //!    - &\[u8\]
    //!  - **FFI types**:
    //!    - CString
    //!    - Box\<CStr\>
    //!    - OsString
    //!  - **Miscellaneous standard library types**:
    //!    - Duration
    //!    - SystemTime
    //!    - Path
    //!    - PathBuf
    //!    - Range\<T\>
    //!    - RangeInclusive\<T\>
    //!    - Bound\<T\>
    //!    - num::NonZero*
    //!    - `!` *(unstable)*
    //!  - **Net types**:
    //!    - IpAddr
    //!    - Ipv4Addr
    //!    - Ipv6Addr
    //!    - SocketAddr
    //!    - SocketAddrV4
    //!    - SocketAddrV6
    //!
    //! [Implementing `Deserialize`]: https://serde.rs/impl-deserialize.html
    //! [`Deserialize`]: crate::Deserialize
    //! [`Deserializer`]: crate::Deserializer
    //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
    //! [`postcard`]: https://github.com/jamesmunns/postcard
    //! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
    //! [`serde_derive`]: https://crates.io/crates/serde_derive
    //! [`serde_json`]: https://github.com/serde-rs/json
    //! [`serde_yaml`]: https://github.com/dtolnay/serde-yaml
    //! [derive section of the manual]: https://serde.rs/derive.html
    //! [data formats]: https://serde.rs/#data-formats
    use crate::lib::*;
    pub mod value {
        //! Building blocks for deserializing basic values using the `IntoDeserializer`
        //! trait.
        //!
        //! ```edition2021
        //! use serde::de::{value, Deserialize, IntoDeserializer};
        //! use serde_derive::Deserialize;
        //! use std::str::FromStr;
        //!
        //! #[derive(Deserialize)]
        //! enum Setting {
        //!     On,
        //!     Off,
        //! }
        //!
        //! impl FromStr for Setting {
        //!     type Err = value::Error;
        //!
        //!     fn from_str(s: &str) -> Result<Self, Self::Err> {
        //!         Self::deserialize(s.into_deserializer())
        //!     }
        //! }
        //! ```
        use crate::lib::*;
        use self::private::{First, Second};
        use crate::de::{
            self, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor,
        };
        use crate::private::size_hint;
        use crate::ser;
        macro_rules! impl_copy_clone {
            ($ty:ident $(<$lifetime:tt>)*) =>
            {
                impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {}
                impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E>
                { fn clone(&self) -> Self { *self } }
            };
        }
        /// A minimal representation of all possible errors that can occur using the
        /// `IntoDeserializer` trait.
        pub struct Error {
            err: ErrorImpl,
        }
        #[automatically_derived]
        impl ::core::clone::Clone for Error {
            #[inline]
            fn clone(&self) -> Error {
                Error { err: ::core::clone::Clone::clone(&self.err) }
            }
        }
        #[automatically_derived]
        impl ::core::marker::StructuralPartialEq for Error { }
        #[automatically_derived]
        impl ::core::cmp::PartialEq for Error {
            #[inline]
            fn eq(&self, other: &Error) -> bool { self.err == other.err }
        }
        type ErrorImpl = Box<str>;
        impl de::Error for Error {
            #[cold]
            fn custom<T>(msg: T) -> Self where T: Display {
                Error { err: msg.to_string().into_boxed_str() }
            }
        }
        impl ser::Error for Error {
            #[cold]
            fn custom<T>(msg: T) -> Self where T: Display {
                de::Error::custom(msg)
            }
        }
        impl Display for Error {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str(&self.err)
            }
        }
        impl Debug for Error {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                let mut debug = formatter.debug_tuple("Error");
                debug.field(&self.err);
                debug.finish()
            }
        }
        #[doc(cfg(feature = "std"))]
        impl error::Error for Error {
            fn description(&self) -> &str { &self.err }
        }
        impl<'de, E> IntoDeserializer<'de, E> for () where E: de::Error {
            type Deserializer = UnitDeserializer<E>;
            fn into_deserializer(self) -> UnitDeserializer<E> {
                UnitDeserializer::new()
            }
        }
        /// A deserializer holding a `()`.
        pub struct UnitDeserializer<E> {
            marker: PhantomData<E>,
        }
        impl<E> Copy for UnitDeserializer<E> {}
        impl<E> Clone for UnitDeserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<E> UnitDeserializer<E> {
            #[allow(missing_docs)]
            pub fn new() -> Self { UnitDeserializer { marker: PhantomData } }
        }
        impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_unit()
            }
            fn deserialize_option<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_none()
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for UnitDeserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for UnitDeserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("UnitDeserializer").finish()
            }
        }
        /// A deserializer that cannot be instantiated.
        #[doc(cfg(feature = "unstable"))]
        pub struct NeverDeserializer<E> {
            never: !,
            marker: PhantomData<E>,
        }
        #[doc(cfg(feature = "unstable"))]
        impl<'de, E> IntoDeserializer<'de, E> for ! where E: de::Error {
            type Deserializer = NeverDeserializer<E>;
            fn into_deserializer(self) -> Self::Deserializer { self }
        }
        impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E> where
            E: de::Error {
            type Error = E;
            fn deserialize_any<V>(self, _visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                self.never
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for NeverDeserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        macro_rules! primitive_deserializer {
            ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) =>
            {
                #[doc = "A deserializer holding"] #[doc = $doc] pub struct
                $name<E> { value: $ty, marker: PhantomData<E> }
                impl_copy_clone!($name); impl<'de, E> IntoDeserializer<'de, E>
                for $ty where E: de::Error,
                {
                    type Deserializer = $name<E>; fn into_deserializer(self) ->
                    $name<E> { $name::new(self) }
                } impl<E> $name<E>
                {
                    #[allow(missing_docs)] pub fn new(value: $ty) -> Self
                    { $name { value, marker: PhantomData, } }
                } impl<'de, E> de::Deserializer<'de> for $name<E> where E:
                de::Error,
                {
                    type Error = E; forward_to_deserialize_any!
                    {
                        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char
                        str string bytes byte_buf option unit unit_struct
                        newtype_struct seq tuple tuple_struct map struct enum
                        identifier ignored_any
                    } fn deserialize_any<V>(self, visitor: V) ->
                    Result<V::Value, Self::Error> where V: de::Visitor<'de>,
                    { visitor.$method(self.value $($cast)*) }
                } impl<'de, E> IntoDeserializer<'de, E> for $name<E> where E:
                de::Error,
                {
                    type Deserializer = Self; fn into_deserializer(self) -> Self
                    { self }
                } impl<E> Debug for $name<E>
                {
                    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result
                    {
                        formatter.debug_struct(stringify!($name)).field("value",
                        &self.value).finish()
                    }
                }
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "a `bool`."]
        pub struct BoolDeserializer<E> {
            value: bool,
            marker: PhantomData<E>,
        }
        impl<E> Copy for BoolDeserializer<E> {}
        impl<E> Clone for BoolDeserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for bool where E: de::Error {
            type Deserializer = BoolDeserializer<E>;
            fn into_deserializer(self) -> BoolDeserializer<E> {
                BoolDeserializer::new(self)
            }
        }
        impl<E> BoolDeserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: bool) -> Self {
                BoolDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for BoolDeserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_bool(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for BoolDeserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for BoolDeserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("BoolDeserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "an `i8`."]
        pub struct I8Deserializer<E> {
            value: i8,
            marker: PhantomData<E>,
        }
        impl<E> Copy for I8Deserializer<E> {}
        impl<E> Clone for I8Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for i8 where E: de::Error {
            type Deserializer = I8Deserializer<E>;
            fn into_deserializer(self) -> I8Deserializer<E> {
                I8Deserializer::new(self)
            }
        }
        impl<E> I8Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: i8) -> Self {
                I8Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for I8Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_i8(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for I8Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for I8Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("I8Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "an `i16`."]
        pub struct I16Deserializer<E> {
            value: i16,
            marker: PhantomData<E>,
        }
        impl<E> Copy for I16Deserializer<E> {}
        impl<E> Clone for I16Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for i16 where E: de::Error {
            type Deserializer = I16Deserializer<E>;
            fn into_deserializer(self) -> I16Deserializer<E> {
                I16Deserializer::new(self)
            }
        }
        impl<E> I16Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: i16) -> Self {
                I16Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for I16Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_i16(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for I16Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for I16Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("I16Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "an `i32`."]
        pub struct I32Deserializer<E> {
            value: i32,
            marker: PhantomData<E>,
        }
        impl<E> Copy for I32Deserializer<E> {}
        impl<E> Clone for I32Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for i32 where E: de::Error {
            type Deserializer = I32Deserializer<E>;
            fn into_deserializer(self) -> I32Deserializer<E> {
                I32Deserializer::new(self)
            }
        }
        impl<E> I32Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: i32) -> Self {
                I32Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for I32Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_i32(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for I32Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for I32Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("I32Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "an `i64`."]
        pub struct I64Deserializer<E> {
            value: i64,
            marker: PhantomData<E>,
        }
        impl<E> Copy for I64Deserializer<E> {}
        impl<E> Clone for I64Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for i64 where E: de::Error {
            type Deserializer = I64Deserializer<E>;
            fn into_deserializer(self) -> I64Deserializer<E> {
                I64Deserializer::new(self)
            }
        }
        impl<E> I64Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: i64) -> Self {
                I64Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for I64Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_i64(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for I64Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for I64Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("I64Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "an `i128`."]
        pub struct I128Deserializer<E> {
            value: i128,
            marker: PhantomData<E>,
        }
        impl<E> Copy for I128Deserializer<E> {}
        impl<E> Clone for I128Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for i128 where E: de::Error {
            type Deserializer = I128Deserializer<E>;
            fn into_deserializer(self) -> I128Deserializer<E> {
                I128Deserializer::new(self)
            }
        }
        impl<E> I128Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: i128) -> Self {
                I128Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for I128Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_i128(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for I128Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for I128Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("I128Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "an `isize`."]
        pub struct IsizeDeserializer<E> {
            value: isize,
            marker: PhantomData<E>,
        }
        impl<E> Copy for IsizeDeserializer<E> {}
        impl<E> Clone for IsizeDeserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for isize where E: de::Error {
            type Deserializer = IsizeDeserializer<E>;
            fn into_deserializer(self) -> IsizeDeserializer<E> {
                IsizeDeserializer::new(self)
            }
        }
        impl<E> IsizeDeserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: isize) -> Self {
                IsizeDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for IsizeDeserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_i64(self.value as i64)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for IsizeDeserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for IsizeDeserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("IsizeDeserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "a `u8`."]
        pub struct U8Deserializer<E> {
            value: u8,
            marker: PhantomData<E>,
        }
        impl<E> Copy for U8Deserializer<E> {}
        impl<E> Clone for U8Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for u8 where E: de::Error {
            type Deserializer = U8Deserializer<E>;
            fn into_deserializer(self) -> U8Deserializer<E> {
                U8Deserializer::new(self)
            }
        }
        impl<E> U8Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: u8) -> Self {
                U8Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for U8Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_u8(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for U8Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for U8Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("U8Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "a `u16`."]
        pub struct U16Deserializer<E> {
            value: u16,
            marker: PhantomData<E>,
        }
        impl<E> Copy for U16Deserializer<E> {}
        impl<E> Clone for U16Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for u16 where E: de::Error {
            type Deserializer = U16Deserializer<E>;
            fn into_deserializer(self) -> U16Deserializer<E> {
                U16Deserializer::new(self)
            }
        }
        impl<E> U16Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: u16) -> Self {
                U16Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for U16Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_u16(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for U16Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for U16Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("U16Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "a `u64`."]
        pub struct U64Deserializer<E> {
            value: u64,
            marker: PhantomData<E>,
        }
        impl<E> Copy for U64Deserializer<E> {}
        impl<E> Clone for U64Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for u64 where E: de::Error {
            type Deserializer = U64Deserializer<E>;
            fn into_deserializer(self) -> U64Deserializer<E> {
                U64Deserializer::new(self)
            }
        }
        impl<E> U64Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: u64) -> Self {
                U64Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for U64Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_u64(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for U64Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for U64Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("U64Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "a `u128`."]
        pub struct U128Deserializer<E> {
            value: u128,
            marker: PhantomData<E>,
        }
        impl<E> Copy for U128Deserializer<E> {}
        impl<E> Clone for U128Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for u128 where E: de::Error {
            type Deserializer = U128Deserializer<E>;
            fn into_deserializer(self) -> U128Deserializer<E> {
                U128Deserializer::new(self)
            }
        }
        impl<E> U128Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: u128) -> Self {
                U128Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for U128Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_u128(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for U128Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for U128Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("U128Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "a `usize`."]
        pub struct UsizeDeserializer<E> {
            value: usize,
            marker: PhantomData<E>,
        }
        impl<E> Copy for UsizeDeserializer<E> {}
        impl<E> Clone for UsizeDeserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for usize where E: de::Error {
            type Deserializer = UsizeDeserializer<E>;
            fn into_deserializer(self) -> UsizeDeserializer<E> {
                UsizeDeserializer::new(self)
            }
        }
        impl<E> UsizeDeserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: usize) -> Self {
                UsizeDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for UsizeDeserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_u64(self.value as u64)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for UsizeDeserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for UsizeDeserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("UsizeDeserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "an `f32`."]
        pub struct F32Deserializer<E> {
            value: f32,
            marker: PhantomData<E>,
        }
        impl<E> Copy for F32Deserializer<E> {}
        impl<E> Clone for F32Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for f32 where E: de::Error {
            type Deserializer = F32Deserializer<E>;
            fn into_deserializer(self) -> F32Deserializer<E> {
                F32Deserializer::new(self)
            }
        }
        impl<E> F32Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: f32) -> Self {
                F32Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for F32Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_f32(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for F32Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for F32Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("F32Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "an `f64`."]
        pub struct F64Deserializer<E> {
            value: f64,
            marker: PhantomData<E>,
        }
        impl<E> Copy for F64Deserializer<E> {}
        impl<E> Clone for F64Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for f64 where E: de::Error {
            type Deserializer = F64Deserializer<E>;
            fn into_deserializer(self) -> F64Deserializer<E> {
                F64Deserializer::new(self)
            }
        }
        impl<E> F64Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: f64) -> Self {
                F64Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for F64Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_f64(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for F64Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for F64Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("F64Deserializer").field("value",
                        &self.value).finish()
            }
        }
        #[doc = "A deserializer holding"]
        #[doc = "a `char`."]
        pub struct CharDeserializer<E> {
            value: char,
            marker: PhantomData<E>,
        }
        impl<E> Copy for CharDeserializer<E> {}
        impl<E> Clone for CharDeserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for char where E: de::Error {
            type Deserializer = CharDeserializer<E>;
            fn into_deserializer(self) -> CharDeserializer<E> {
                CharDeserializer::new(self)
            }
        }
        impl<E> CharDeserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: char) -> Self {
                CharDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for CharDeserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_char(self.value)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for CharDeserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<E> Debug for CharDeserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("CharDeserializer").field("value",
                        &self.value).finish()
            }
        }
        /// A deserializer holding a `u32`.
        pub struct U32Deserializer<E> {
            value: u32,
            marker: PhantomData<E>,
        }
        impl<E> Copy for U32Deserializer<E> {}
        impl<E> Clone for U32Deserializer<E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> IntoDeserializer<'de, E> for u32 where E: de::Error {
            type Deserializer = U32Deserializer<E>;
            fn into_deserializer(self) -> U32Deserializer<E> {
                U32Deserializer::new(self)
            }
        }
        impl<E> U32Deserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: u32) -> Self {
                U32Deserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for U32Deserializer<E> where
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_u32(self.value)
            }
            fn deserialize_enum<V>(self, name: &str,
                variants: &'static [&'static str], visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                visitor.visit_enum(self)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for U32Deserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E> where
            E: de::Error {
            type Error = E;
            type Variant = private::UnitOnly<E>;
            fn variant_seed<T>(self, seed: T)
                -> Result<(T::Value, Self::Variant), Self::Error> where
                T: de::DeserializeSeed<'de> {
                seed.deserialize(self).map(private::unit_only)
            }
        }
        impl<E> Debug for U32Deserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("U32Deserializer").field("value",
                        &self.value).finish()
            }
        }
        /// A deserializer holding a `&str`.
        pub struct StrDeserializer<'a, E> {
            value: &'a str,
            marker: PhantomData<E>,
        }
        impl<'de, E> Copy for StrDeserializer<'de, E> {}
        impl<'de, E> Clone for StrDeserializer<'de, E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str where
            E: de::Error {
            type Deserializer = StrDeserializer<'a, E>;
            fn into_deserializer(self) -> StrDeserializer<'a, E> {
                StrDeserializer::new(self)
            }
        }
        impl<'a, E> StrDeserializer<'a, E> {
            #[allow(missing_docs)]
            pub fn new(value: &'a str) -> Self {
                StrDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E>
            where E: de::Error {
            type Error = E;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_str(self.value)
            }
            fn deserialize_enum<V>(self, name: &str,
                variants: &'static [&'static str], visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                visitor.visit_enum(self)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, 'a, E> IntoDeserializer<'de, E> for StrDeserializer<'a, E>
            where E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E> where
            E: de::Error {
            type Error = E;
            type Variant = private::UnitOnly<E>;
            fn variant_seed<T>(self, seed: T)
                -> Result<(T::Value, Self::Variant), Self::Error> where
                T: de::DeserializeSeed<'de> {
                seed.deserialize(self).map(private::unit_only)
            }
        }
        impl<'a, E> Debug for StrDeserializer<'a, E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("StrDeserializer").field("value",
                        &self.value).finish()
            }
        }
        /// A deserializer holding a `&str` with a lifetime tied to another
        /// deserializer.
        pub struct BorrowedStrDeserializer<'de, E> {
            value: &'de str,
            marker: PhantomData<E>,
        }
        impl<'de, E> Copy for BorrowedStrDeserializer<'de, E> {}
        impl<'de, E> Clone for BorrowedStrDeserializer<'de, E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> BorrowedStrDeserializer<'de, E> {
            /// Create a new borrowed deserializer from the given string.
            pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
                BorrowedStrDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E>
            where E: de::Error {
            type Error = E;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_borrowed_str(self.value)
            }
            fn deserialize_enum<V>(self, name: &str,
                variants: &'static [&'static str], visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                visitor.visit_enum(self)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for
            BorrowedStrDeserializer<'de, E> where E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E>
            where E: de::Error {
            type Error = E;
            type Variant = private::UnitOnly<E>;
            fn variant_seed<T>(self, seed: T)
                -> Result<(T::Value, Self::Variant), Self::Error> where
                T: de::DeserializeSeed<'de> {
                seed.deserialize(self).map(private::unit_only)
            }
        }
        impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("BorrowedStrDeserializer").field("value",
                        &self.value).finish()
            }
        }
        /// A deserializer holding a `String`.
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        pub struct StringDeserializer<E> {
            value: String,
            marker: PhantomData<E>,
        }
        impl<E> Clone for StringDeserializer<E> {
            fn clone(&self) -> Self {
                StringDeserializer {
                    value: self.value.clone(),
                    marker: PhantomData,
                }
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, E> IntoDeserializer<'de, E> for String where E: de::Error {
            type Deserializer = StringDeserializer<E>;
            fn into_deserializer(self) -> StringDeserializer<E> {
                StringDeserializer::new(self)
            }
        }
        impl<E> StringDeserializer<E> {
            #[allow(missing_docs)]
            pub fn new(value: String) -> Self {
                StringDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> de::Deserializer<'de> for StringDeserializer<E> where
            E: de::Error {
            type Error = E;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_string(self.value)
            }
            fn deserialize_enum<V>(self, name: &str,
                variants: &'static [&'static str], visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                visitor.visit_enum(self)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for StringDeserializer<E> where
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, E> de::EnumAccess<'de> for StringDeserializer<E> where
            E: de::Error {
            type Error = E;
            type Variant = private::UnitOnly<E>;
            fn variant_seed<T>(self, seed: T)
                -> Result<(T::Value, Self::Variant), Self::Error> where
                T: de::DeserializeSeed<'de> {
                seed.deserialize(self).map(private::unit_only)
            }
        }
        impl<E> Debug for StringDeserializer<E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("StringDeserializer").field("value",
                        &self.value).finish()
            }
        }
        /// A deserializer holding a `Cow<str>`.
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        pub struct CowStrDeserializer<'a, E> {
            value: Cow<'a, str>,
            marker: PhantomData<E>,
        }
        impl<'a, E> Clone for CowStrDeserializer<'a, E> {
            fn clone(&self) -> Self {
                CowStrDeserializer {
                    value: self.value.clone(),
                    marker: PhantomData,
                }
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str> where
            E: de::Error {
            type Deserializer = CowStrDeserializer<'a, E>;
            fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
                CowStrDeserializer::new(self)
            }
        }
        impl<'a, E> CowStrDeserializer<'a, E> {
            #[allow(missing_docs)]
            pub fn new(value: Cow<'a, str>) -> Self {
                CowStrDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
            where E: de::Error {
            type Error = E;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                match self.value {
                    Cow::Borrowed(string) => visitor.visit_str(string),
                    Cow::Owned(string) => visitor.visit_string(string),
                }
            }
            fn deserialize_enum<V>(self, name: &str,
                variants: &'static [&'static str], visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                visitor.visit_enum(self)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, 'a, E> IntoDeserializer<'de, E> for
            CowStrDeserializer<'a, E> where E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E>
            where E: de::Error {
            type Error = E;
            type Variant = private::UnitOnly<E>;
            fn variant_seed<T>(self, seed: T)
                -> Result<(T::Value, Self::Variant), Self::Error> where
                T: de::DeserializeSeed<'de> {
                seed.deserialize(self).map(private::unit_only)
            }
        }
        impl<'a, E> Debug for CowStrDeserializer<'a, E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("CowStrDeserializer").field("value",
                        &self.value).finish()
            }
        }
        /// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`].
        pub struct BytesDeserializer<'a, E> {
            value: &'a [u8],
            marker: PhantomData<E>,
        }
        impl<'a, E> BytesDeserializer<'a, E> {
            /// Create a new deserializer from the given bytes.
            pub fn new(value: &'a [u8]) -> Self {
                BytesDeserializer { value, marker: PhantomData }
            }
        }
        impl<'a, E> Copy for BytesDeserializer<'a, E> {}
        impl<'a, E> Clone for BytesDeserializer<'a, E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a [u8] where
            E: de::Error {
            type Deserializer = BytesDeserializer<'a, E>;
            fn into_deserializer(self) -> BytesDeserializer<'a, E> {
                BytesDeserializer::new(self)
            }
        }
        impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E> where
            E: de::Error {
            type Error = E;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: Visitor<'de> {
                visitor.visit_bytes(self.value)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, 'a, E> IntoDeserializer<'de, E> for BytesDeserializer<'a, E>
            where E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'a, E> Debug for BytesDeserializer<'a, E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("BytesDeserializer").field("value",
                        &self.value).finish()
            }
        }
        /// A deserializer holding a `&[u8]` with a lifetime tied to another
        /// deserializer. Always calls [`Visitor::visit_borrowed_bytes`].
        pub struct BorrowedBytesDeserializer<'de, E> {
            value: &'de [u8],
            marker: PhantomData<E>,
        }
        impl<'de, E> BorrowedBytesDeserializer<'de, E> {
            /// Create a new borrowed deserializer from the given borrowed bytes.
            pub fn new(value: &'de [u8]) -> Self {
                BorrowedBytesDeserializer { value, marker: PhantomData }
            }
        }
        impl<'de, E> Copy for BorrowedBytesDeserializer<'de, E> {}
        impl<'de, E> Clone for BorrowedBytesDeserializer<'de, E> {
            fn clone(&self) -> Self { *self }
        }
        impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
            where E: de::Error {
            type Error = E;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: Visitor<'de> {
                visitor.visit_borrowed_bytes(self.value)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, E> IntoDeserializer<'de, E> for
            BorrowedBytesDeserializer<'de, E> where E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("BorrowedBytesDeserializer").field("value",
                        &self.value).finish()
            }
        }
        /// A deserializer that iterates over a sequence.
        pub struct SeqDeserializer<I, E> {
            iter: iter::Fuse<I>,
            count: usize,
            marker: PhantomData<E>,
        }
        #[automatically_derived]
        impl<I: ::core::clone::Clone, E: ::core::clone::Clone>
            ::core::clone::Clone for SeqDeserializer<I, E> {
            #[inline]
            fn clone(&self) -> SeqDeserializer<I, E> {
                SeqDeserializer {
                    iter: ::core::clone::Clone::clone(&self.iter),
                    count: ::core::clone::Clone::clone(&self.count),
                    marker: ::core::clone::Clone::clone(&self.marker),
                }
            }
        }
        impl<I, E> SeqDeserializer<I, E> where I: Iterator {
            /// Construct a new `SeqDeserializer<I, E>`.
            pub fn new(iter: I) -> Self {
                SeqDeserializer {
                    iter: iter.fuse(),
                    count: 0,
                    marker: PhantomData,
                }
            }
        }
        impl<I, E> SeqDeserializer<I, E> where I: Iterator, E: de::Error {
            /// Check for remaining elements after passing a `SeqDeserializer` to
            /// `Visitor::visit_seq`.
            pub fn end(self) -> Result<(), E> {
                let remaining = self.iter.count();
                if remaining == 0 {
                    Ok(())
                } else {
                    Err(de::Error::invalid_length(self.count + remaining,
                            &ExpectedInSeq(self.count)))
                }
            }
        }
        impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E>
            where I: Iterator<Item = T>, T: IntoDeserializer<'de, E>,
            E: de::Error {
            type Error = E;
            fn deserialize_any<V>(mut self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let v =
                    match visitor.visit_seq(&mut self) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match self.end() {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                Ok(v)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, I, T, E> IntoDeserializer<'de, E> for SeqDeserializer<I, E>
            where I: Iterator<Item = T>, T: IntoDeserializer<'de, E>,
            E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E> where
            I: Iterator<Item = T>, T: IntoDeserializer<'de, E>, E: de::Error {
            type Error = E;
            fn next_element_seed<V>(&mut self, seed: V)
                -> Result<Option<V::Value>, Self::Error> where
                V: de::DeserializeSeed<'de> {
                match self.iter.next() {
                    Some(value) => {
                        self.count += 1;
                        seed.deserialize(value.into_deserializer()).map(Some)
                    }
                    None => Ok(None),
                }
            }
            fn size_hint(&self) -> Option<usize> {
                size_hint::from_bounds(&self.iter)
            }
        }
        struct ExpectedInSeq(usize);
        impl Expected for ExpectedInSeq {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                if self.0 == 1 {
                    formatter.write_str("1 element in sequence")
                } else {
                    formatter.write_fmt(format_args!("{0} elements in sequence",
                            self.0))
                }
            }
        }
        impl<I, E> Debug for SeqDeserializer<I, E> where I: Debug {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("SeqDeserializer").field("iter",
                            &self.iter).field("count", &self.count).finish()
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T> where
            T: IntoDeserializer<'de, E>, E: de::Error {
            type Deserializer =
                SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
            fn into_deserializer(self) -> Self::Deserializer {
                SeqDeserializer::new(self.into_iter())
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T> where
            T: IntoDeserializer<'de, E> + Eq + Ord, E: de::Error {
            type Deserializer =
                SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
            fn into_deserializer(self) -> Self::Deserializer {
                SeqDeserializer::new(self.into_iter())
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S> where
            T: IntoDeserializer<'de, E> + Eq + Hash, S: BuildHasher,
            E: de::Error {
            type Deserializer =
                SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
            fn into_deserializer(self) -> Self::Deserializer {
                SeqDeserializer::new(self.into_iter())
            }
        }
        /// A deserializer holding a `SeqAccess`.
        pub struct SeqAccessDeserializer<A> {
            seq: A,
        }
        #[automatically_derived]
        impl<A: ::core::clone::Clone> ::core::clone::Clone for
            SeqAccessDeserializer<A> {
            #[inline]
            fn clone(&self) -> SeqAccessDeserializer<A> {
                SeqAccessDeserializer {
                    seq: ::core::clone::Clone::clone(&self.seq),
                }
            }
        }
        #[automatically_derived]
        impl<A: ::core::fmt::Debug> ::core::fmt::Debug for
            SeqAccessDeserializer<A> {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
                -> ::core::fmt::Result {
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "SeqAccessDeserializer", "seq", &&self.seq)
            }
        }
        impl<A> SeqAccessDeserializer<A> {
            /// Construct a new `SeqAccessDeserializer<A>`.
            pub fn new(seq: A) -> Self { SeqAccessDeserializer { seq } }
        }
        impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A> where
            A: de::SeqAccess<'de> {
            type Error = A::Error;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_seq(self.seq)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, A> IntoDeserializer<'de, A::Error> for
            SeqAccessDeserializer<A> where A: de::SeqAccess<'de> {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        /// A deserializer that iterates over a map.
        pub struct MapDeserializer<'de, I, E> where I: Iterator,
            I::Item: private::Pair {
            iter: iter::Fuse<I>,
            value: Option<Second<I::Item>>,
            count: usize,
            lifetime: PhantomData<&'de ()>,
            error: PhantomData<E>,
        }
        impl<'de, I, E> MapDeserializer<'de, I, E> where I: Iterator,
            I::Item: private::Pair {
            /// Construct a new `MapDeserializer<I, E>`.
            pub fn new(iter: I) -> Self {
                MapDeserializer {
                    iter: iter.fuse(),
                    value: None,
                    count: 0,
                    lifetime: PhantomData,
                    error: PhantomData,
                }
            }
        }
        impl<'de, I, E> MapDeserializer<'de, I, E> where I: Iterator,
            I::Item: private::Pair, E: de::Error {
            /// Check for remaining elements after passing a `MapDeserializer` to
            /// `Visitor::visit_map`.
            pub fn end(self) -> Result<(), E> {
                let remaining = self.iter.count();
                if remaining == 0 {
                    Ok(())
                } else {
                    Err(de::Error::invalid_length(self.count + remaining,
                            &ExpectedInMap(self.count)))
                }
            }
        }
        impl<'de, I, E> MapDeserializer<'de, I, E> where I: Iterator,
            I::Item: private::Pair {
            fn next_pair(&mut self)
                -> Option<(First<I::Item>, Second<I::Item>)> {
                match self.iter.next() {
                    Some(kv) => {
                        self.count += 1;
                        Some(private::Pair::split(kv))
                    }
                    None => None,
                }
            }
        }
        impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
            where I: Iterator, I::Item: private::Pair,
            First<I::Item>: IntoDeserializer<'de, E>,
            Second<I::Item>: IntoDeserializer<'de, E>, E: de::Error {
            type Error = E;
            fn deserialize_any<V>(mut self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let value =
                    match visitor.visit_map(&mut self) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match self.end() {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                Ok(value)
            }
            fn deserialize_seq<V>(mut self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let value =
                    match visitor.visit_seq(&mut self) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match self.end() {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                Ok(value)
            }
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let _ = len;
                self.deserialize_seq(visitor)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, I, E> IntoDeserializer<'de, E> for
            MapDeserializer<'de, I, E> where I: Iterator,
            I::Item: private::Pair, First<I::Item>: IntoDeserializer<'de, E>,
            Second<I::Item>: IntoDeserializer<'de, E>, E: de::Error {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E>
            where I: Iterator, I::Item: private::Pair,
            First<I::Item>: IntoDeserializer<'de, E>,
            Second<I::Item>: IntoDeserializer<'de, E>, E: de::Error {
            type Error = E;
            fn next_key_seed<T>(&mut self, seed: T)
                -> Result<Option<T::Value>, Self::Error> where
                T: de::DeserializeSeed<'de> {
                match self.next_pair() {
                    Some((key, value)) => {
                        self.value = Some(value);
                        seed.deserialize(key.into_deserializer()).map(Some)
                    }
                    None => Ok(None),
                }
            }
            fn next_value_seed<T>(&mut self, seed: T)
                -> Result<T::Value, Self::Error> where
                T: de::DeserializeSeed<'de> {
                let value = self.value.take();
                let value =
                    value.expect("MapAccess::next_value called before next_key");
                seed.deserialize(value.into_deserializer())
            }
            fn next_entry_seed<TK, TV>(&mut self, kseed: TK, vseed: TV)
                -> Result<Option<(TK::Value, TV::Value)>, Self::Error> where
                TK: de::DeserializeSeed<'de>, TV: de::DeserializeSeed<'de> {
                match self.next_pair() {
                    Some((key, value)) => {
                        let key =
                            match kseed.deserialize(key.into_deserializer()) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            };
                        let value =
                            match vseed.deserialize(value.into_deserializer()) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            };
                        Ok(Some((key, value)))
                    }
                    None => Ok(None),
                }
            }
            fn size_hint(&self) -> Option<usize> {
                size_hint::from_bounds(&self.iter)
            }
        }
        impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E>
            where I: Iterator, I::Item: private::Pair,
            First<I::Item>: IntoDeserializer<'de, E>,
            Second<I::Item>: IntoDeserializer<'de, E>, E: de::Error {
            type Error = E;
            fn next_element_seed<T>(&mut self, seed: T)
                -> Result<Option<T::Value>, Self::Error> where
                T: de::DeserializeSeed<'de> {
                match self.next_pair() {
                    Some((k, v)) => {
                        let de = PairDeserializer(k, v, PhantomData);
                        seed.deserialize(de).map(Some)
                    }
                    None => Ok(None),
                }
            }
            fn size_hint(&self) -> Option<usize> {
                size_hint::from_bounds(&self.iter)
            }
        }
        impl<'de, I, E> Clone for MapDeserializer<'de, I, E> where
            I: Iterator + Clone, I::Item: private::Pair,
            Second<I::Item>: Clone {
            fn clone(&self) -> Self {
                MapDeserializer {
                    iter: self.iter.clone(),
                    value: self.value.clone(),
                    count: self.count,
                    lifetime: self.lifetime,
                    error: self.error,
                }
            }
        }
        impl<'de, I, E> Debug for MapDeserializer<'de, I, E> where
            I: Iterator + Debug, I::Item: private::Pair,
            Second<I::Item>: Debug {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.debug_struct("MapDeserializer").field("iter",
                                &self.iter).field("value",
                            &self.value).field("count", &self.count).finish()
            }
        }
        struct PairDeserializer<A, B, E>(A, B, PhantomData<E>);
        impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
            where A: IntoDeserializer<'de, E>, B: IntoDeserializer<'de, E>,
            E: de::Error {
            type Error = E;
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                self.deserialize_seq(visitor)
            }
            fn deserialize_seq<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                let mut pair_visitor =
                    PairVisitor(Some(self.0), Some(self.1), PhantomData);
                let pair =
                    match visitor.visit_seq(&mut pair_visitor) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                if pair_visitor.1.is_none() {
                    Ok(pair)
                } else {
                    let remaining = pair_visitor.size_hint().unwrap();
                    Err(de::Error::invalid_length(2,
                            &ExpectedInSeq(2 - remaining)))
                }
            }
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                if len == 2 {
                    self.deserialize_seq(visitor)
                } else {
                    Err(de::Error::invalid_length(2, &ExpectedInSeq(len)))
                }
            }
        }
        struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
        impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E> where
            A: IntoDeserializer<'de, E>, B: IntoDeserializer<'de, E>,
            E: de::Error {
            type Error = E;
            fn next_element_seed<T>(&mut self, seed: T)
                -> Result<Option<T::Value>, Self::Error> where
                T: de::DeserializeSeed<'de> {
                if let Some(k) = self.0.take() {
                    seed.deserialize(k.into_deserializer()).map(Some)
                } else if let Some(v) = self.1.take() {
                    seed.deserialize(v.into_deserializer()).map(Some)
                } else { Ok(None) }
            }
            fn size_hint(&self) -> Option<usize> {
                if self.0.is_some() {
                    Some(2)
                } else if self.1.is_some() { Some(1) } else { Some(0) }
            }
        }
        struct ExpectedInMap(usize);
        impl Expected for ExpectedInMap {
            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                if self.0 == 1 {
                    formatter.write_str("1 element in map")
                } else {
                    formatter.write_fmt(format_args!("{0} elements in map",
                            self.0))
                }
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V> where
            K: IntoDeserializer<'de, E> + Eq + Ord,
            V: IntoDeserializer<'de, E>, E: de::Error {
            type Deserializer =
                MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
            fn into_deserializer(self) -> Self::Deserializer {
                MapDeserializer::new(self.into_iter())
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
            where K: IntoDeserializer<'de, E> + Eq + Hash,
            V: IntoDeserializer<'de, E>, S: BuildHasher, E: de::Error {
            type Deserializer =
                MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
            fn into_deserializer(self) -> Self::Deserializer {
                MapDeserializer::new(self.into_iter())
            }
        }
        /// A deserializer holding a `MapAccess`.
        pub struct MapAccessDeserializer<A> {
            map: A,
        }
        #[automatically_derived]
        impl<A: ::core::clone::Clone> ::core::clone::Clone for
            MapAccessDeserializer<A> {
            #[inline]
            fn clone(&self) -> MapAccessDeserializer<A> {
                MapAccessDeserializer {
                    map: ::core::clone::Clone::clone(&self.map),
                }
            }
        }
        #[automatically_derived]
        impl<A: ::core::fmt::Debug> ::core::fmt::Debug for
            MapAccessDeserializer<A> {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
                -> ::core::fmt::Result {
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "MapAccessDeserializer", "map", &&self.map)
            }
        }
        impl<A> MapAccessDeserializer<A> {
            /// Construct a new `MapAccessDeserializer<A>`.
            pub fn new(map: A) -> Self { MapAccessDeserializer { map } }
        }
        impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A> where
            A: de::MapAccess<'de> {
            type Error = A::Error;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_map(self.map)
            }
            fn deserialize_enum<V>(self, _name: &str,
                _variants: &'static [&'static str], visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_enum(self)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, A> IntoDeserializer<'de, A::Error> for
            MapAccessDeserializer<A> where A: de::MapAccess<'de> {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A> where
            A: de::MapAccess<'de> {
            type Error = A::Error;
            type Variant = private::MapAsEnum<A>;
            fn variant_seed<T>(mut self, seed: T)
                -> Result<(T::Value, Self::Variant), Self::Error> where
                T: de::DeserializeSeed<'de> {
                match match self.map.next_key_seed(seed) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    } {
                    Some(key) => Ok((key, private::map_as_enum(self.map))),
                    None =>
                        Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
                }
            }
        }
        /// A deserializer holding an `EnumAccess`.
        pub struct EnumAccessDeserializer<A> {
            access: A,
        }
        #[automatically_derived]
        impl<A: ::core::clone::Clone> ::core::clone::Clone for
            EnumAccessDeserializer<A> {
            #[inline]
            fn clone(&self) -> EnumAccessDeserializer<A> {
                EnumAccessDeserializer {
                    access: ::core::clone::Clone::clone(&self.access),
                }
            }
        }
        #[automatically_derived]
        impl<A: ::core::fmt::Debug> ::core::fmt::Debug for
            EnumAccessDeserializer<A> {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
                -> ::core::fmt::Result {
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "EnumAccessDeserializer", "access", &&self.access)
            }
        }
        impl<A> EnumAccessDeserializer<A> {
            /// Construct a new `EnumAccessDeserializer<A>`.
            pub fn new(access: A) -> Self {
                EnumAccessDeserializer { access }
            }
        }
        impl<'de, A> de::Deserializer<'de> for EnumAccessDeserializer<A> where
            A: de::EnumAccess<'de> {
            type Error = A::Error;
            fn deserialize_any<V>(self, visitor: V)
                -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                visitor.visit_enum(self.access)
            }
            #[inline]
            fn deserialize_bool<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_i128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u8<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u16<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_u128<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f32<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_f64<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_char<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_str<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_string<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_bytes<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_byte_buf<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_option<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_unit_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_newtype_struct<V>(self, name: &'static str,
                visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_seq<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple<V>(self, len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_tuple_struct<V>(self, name: &'static str,
                len: usize, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = len;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_map<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_struct<V>(self, name: &'static str,
                fields: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = fields;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_enum<V>(self, name: &'static str,
                variants: &'static [&'static str], visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                let _ = name;
                let _ = variants;
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_identifier<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
            #[inline]
            fn deserialize_ignored_any<V>(self, visitor: V)
                ->
                    crate::__private::Result<V::Value,
                    <Self as crate::de::Deserializer<'de>>::Error> where
                V: crate::de::Visitor<'de> {
                self.deserialize_any(visitor)
            }
        }
        impl<'de, A> IntoDeserializer<'de, A::Error> for
            EnumAccessDeserializer<A> where A: de::EnumAccess<'de> {
            type Deserializer = Self;
            fn into_deserializer(self) -> Self { self }
        }
        mod private {
            use crate::lib::*;
            use crate::de::{
                self, DeserializeSeed, Deserializer, MapAccess, Unexpected,
                VariantAccess, Visitor,
            };
            pub struct UnitOnly<E> {
                marker: PhantomData<E>,
            }
            pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
                (t, UnitOnly { marker: PhantomData })
            }
            impl<'de, E> de::VariantAccess<'de> for UnitOnly<E> where
                E: de::Error {
                type Error = E;
                fn unit_variant(self) -> Result<(), Self::Error> { Ok(()) }
                fn newtype_variant_seed<T>(self, _seed: T)
                    -> Result<T::Value, Self::Error> where
                    T: de::DeserializeSeed<'de> {
                    Err(de::Error::invalid_type(Unexpected::UnitVariant,
                            &"newtype variant"))
                }
                fn tuple_variant<V>(self, _len: usize, _visitor: V)
                    -> Result<V::Value, Self::Error> where V: de::Visitor<'de> {
                    Err(de::Error::invalid_type(Unexpected::UnitVariant,
                            &"tuple variant"))
                }
                fn struct_variant<V>(self, _fields: &'static [&'static str],
                    _visitor: V) -> Result<V::Value, Self::Error> where
                    V: de::Visitor<'de> {
                    Err(de::Error::invalid_type(Unexpected::UnitVariant,
                            &"struct variant"))
                }
            }
            pub struct MapAsEnum<A> {
                map: A,
            }
            pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
                MapAsEnum { map }
            }
            impl<'de, A> VariantAccess<'de> for MapAsEnum<A> where
                A: MapAccess<'de> {
                type Error = A::Error;
                fn unit_variant(mut self) -> Result<(), Self::Error> {
                    self.map.next_value()
                }
                fn newtype_variant_seed<T>(mut self, seed: T)
                    -> Result<T::Value, Self::Error> where
                    T: DeserializeSeed<'de> {
                    self.map.next_value_seed(seed)
                }
                fn tuple_variant<V>(mut self, len: usize, visitor: V)
                    -> Result<V::Value, Self::Error> where V: Visitor<'de> {
                    self.map.next_value_seed(SeedTupleVariant { len, visitor })
                }
                fn struct_variant<V>(mut self,
                    _fields: &'static [&'static str], visitor: V)
                    -> Result<V::Value, Self::Error> where V: Visitor<'de> {
                    self.map.next_value_seed(SeedStructVariant { visitor })
                }
            }
            struct SeedTupleVariant<V> {
                len: usize,
                visitor: V,
            }
            impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V> where
                V: Visitor<'de> {
                type Value = V::Value;
                fn deserialize<D>(self, deserializer: D)
                    -> Result<Self::Value, D::Error> where
                    D: Deserializer<'de> {
                    deserializer.deserialize_tuple(self.len, self.visitor)
                }
            }
            struct SeedStructVariant<V> {
                visitor: V,
            }
            impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V> where
                V: Visitor<'de> {
                type Value = V::Value;
                fn deserialize<D>(self, deserializer: D)
                    -> Result<Self::Value, D::Error> where
                    D: Deserializer<'de> {
                    deserializer.deserialize_map(self.visitor)
                }
            }
            /// Avoid having to restate the generic types on `MapDeserializer`. The
            /// `Iterator::Item` contains enough information to figure out K and V.
            pub trait Pair {
                type First;
                type Second;
                fn split(self)
                -> (Self::First, Self::Second);
            }
            impl<A, B> Pair for (A, B) {
                type First = A;
                type Second = B;
                fn split(self) -> (A, B) { self }
            }
            pub type First<T> = <T as Pair>::First;
            pub type Second<T> = <T as Pair>::Second;
        }
    }
    mod ignored_any {
        use crate::lib::*;
        use crate::de::{
            Deserialize, Deserializer, EnumAccess, Error, MapAccess,
            SeqAccess, VariantAccess, Visitor,
        };
        /// An efficient way of discarding data from a deserializer.
        ///
        /// Think of this like `serde_json::Value` in that it can be deserialized from
        /// any type, except that it does not store any information about the data that
        /// gets deserialized.
        ///
        /// ```edition2021
        /// use serde::de::{
        ///     self, Deserialize, DeserializeSeed, Deserializer, IgnoredAny, SeqAccess, Visitor,
        /// };
        /// use std::fmt;
        /// use std::marker::PhantomData;
        ///
        /// /// A seed that can be used to deserialize only the `n`th element of a sequence
        /// /// while efficiently discarding elements of any type before or after index `n`.
        /// ///
        /// /// For example to deserialize only the element at index 3:
        /// ///
        /// /// ```
        /// /// NthElement::new(3).deserialize(deserializer)
        /// /// ```
        /// pub struct NthElement<T> {
        ///     n: usize,
        ///     marker: PhantomData<T>,
        /// }
        ///
        /// impl<T> NthElement<T> {
        ///     pub fn new(n: usize) -> Self {
        ///         NthElement {
        ///             n: n,
        ///             marker: PhantomData,
        ///         }
        ///     }
        /// }
        ///
        /// impl<'de, T> Visitor<'de> for NthElement<T>
        /// where
        ///     T: Deserialize<'de>,
        /// {
        ///     type Value = T;
        ///
        ///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        ///         write!(
        ///             formatter,
        ///             "a sequence in which we care about element {}",
        ///             self.n
        ///         )
        ///     }
        ///
        ///     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
        ///     where
        ///         A: SeqAccess<'de>,
        ///     {
        ///         // Skip over the first `n` elements.
        ///         for i in 0..self.n {
        ///             // It is an error if the sequence ends before we get to element `n`.
        ///             if seq.next_element::<IgnoredAny>()?.is_none() {
        ///                 return Err(de::Error::invalid_length(i, &self));
        ///             }
        ///         }
        ///
        ///         // Deserialize the one we care about.
        ///         let nth = match seq.next_element()? {
        ///             Some(nth) => nth,
        ///             None => {
        ///                 return Err(de::Error::invalid_length(self.n, &self));
        ///             }
        ///         };
        ///
        ///         // Skip over any remaining elements in the sequence after `n`.
        ///         while let Some(IgnoredAny) = seq.next_element()? {
        ///             // ignore
        ///         }
        ///
        ///         Ok(nth)
        ///     }
        /// }
        ///
        /// impl<'de, T> DeserializeSeed<'de> for NthElement<T>
        /// where
        ///     T: Deserialize<'de>,
        /// {
        ///     type Value = T;
        ///
        ///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
        ///     where
        ///         D: Deserializer<'de>,
        ///     {
        ///         deserializer.deserialize_seq(self)
        ///     }
        /// }
        ///
        /// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
        /// # where
        /// #     D: Deserializer<'de>,
        /// # {
        /// // Deserialize only the sequence element at index 3 from this deserializer.
        /// // The element at index 3 is required to be a string. Elements before and
        /// // after index 3 are allowed to be of any type.
        /// let s: String = NthElement::new(3).deserialize(deserializer)?;
        /// #     Ok(())
        /// # }
        /// ```
        pub struct IgnoredAny;
        #[automatically_derived]
        impl ::core::marker::Copy for IgnoredAny { }
        #[automatically_derived]
        impl ::core::clone::Clone for IgnoredAny {
            #[inline]
            fn clone(&self) -> IgnoredAny { *self }
        }
        #[automatically_derived]
        impl ::core::fmt::Debug for IgnoredAny {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
                -> ::core::fmt::Result {
                ::core::fmt::Formatter::write_str(f, "IgnoredAny")
            }
        }
        #[automatically_derived]
        impl ::core::default::Default for IgnoredAny {
            #[inline]
            fn default() -> IgnoredAny { IgnoredAny {} }
        }
        #[automatically_derived]
        impl ::core::marker::StructuralPartialEq for IgnoredAny { }
        #[automatically_derived]
        impl ::core::cmp::PartialEq for IgnoredAny {
            #[inline]
            fn eq(&self, other: &IgnoredAny) -> bool { true }
        }
        impl<'de> Visitor<'de> for IgnoredAny {
            type Value = IgnoredAny;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("anything at all")
            }
            #[inline]
            fn visit_bool<E>(self, x: bool) -> Result<Self::Value, E> {
                let _ = x;
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_i64<E>(self, x: i64) -> Result<Self::Value, E> {
                let _ = x;
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
                let _ = x;
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E> {
                let _ = x;
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
                let _ = x;
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
                let _ = x;
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E> where
                E: Error {
                let _ = s;
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_none<E>(self) -> Result<Self::Value, E> {
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_some<D>(self, deserializer: D)
                -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
                IgnoredAny::deserialize(deserializer)
            }
            #[inline]
            fn visit_newtype_struct<D>(self, deserializer: D)
                -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
                IgnoredAny::deserialize(deserializer)
            }
            #[inline]
            fn visit_unit<E>(self) -> Result<Self::Value, E> {
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                while let Some(IgnoredAny) =
                        match seq.next_element() {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        } {}
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
                where A: MapAccess<'de> {
                while let Some((IgnoredAny, IgnoredAny)) =
                        match map.next_entry() {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        } {}
                Ok(IgnoredAny)
            }
            #[inline]
            fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
                where E: Error {
                let _ = bytes;
                Ok(IgnoredAny)
            }
            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
                where A: EnumAccess<'de> {
                match data.variant::<IgnoredAny>() {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        }.1.newtype_variant()
            }
        }
        impl<'de> Deserialize<'de> for IgnoredAny {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
                where D: Deserializer<'de> {
                deserializer.deserialize_ignored_any(IgnoredAny)
            }
        }
    }
    mod impls {
        use crate::lib::*;
        use crate::de::{
            Deserialize, Deserializer, EnumAccess, Error, MapAccess,
            SeqAccess, Unexpected, VariantAccess, Visitor,
        };
        use crate::private::{self, InPlaceSeed};
        use crate::private::size_hint;
        struct UnitVisitor;
        impl<'de> Visitor<'de> for UnitVisitor {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("unit")
            }
            fn visit_unit<E>(self) -> Result<Self::Value, E> where E: Error {
                Ok(())
            }
        }
        impl<'de> Deserialize<'de> for () {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_unit(UnitVisitor)
            }
        }
        #[doc(cfg(feature = "unstable"))]
        impl<'de> Deserialize<'de> for ! {
            fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
                where D: Deserializer<'de> {
                Err(Error::custom("cannot deserialize `!`"))
            }
        }
        struct BoolVisitor;
        impl<'de> Visitor<'de> for BoolVisitor {
            type Value = bool;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("a boolean")
            }
            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E> where
                E: Error {
                Ok(v)
            }
        }
        impl<'de> Deserialize<'de> for bool {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_bool(BoolVisitor)
            }
        }
        macro_rules! impl_deserialize_num {
            ($primitive:ident, $nonzero:ident, $deserialize:ident
            $($method:ident!($($val:ident : $visit:ident)*);)*) =>
            {
                impl_deserialize_num!($primitive, $deserialize
                $($method!($($val : $visit)*);)*); impl<'de> Deserialize<'de>
                for num::$nonzero
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    {
                        struct NonZeroVisitor; impl<'de> Visitor<'de> for
                        NonZeroVisitor
                        {
                            type Value = num::$nonzero; fn
                            expecting(&self, formatter: &mut fmt::Formatter) ->
                            fmt::Result
                            {
                                formatter.write_str(concat!("a nonzero ",
                                stringify!($primitive)))
                            } $($($method!(nonzero $primitive $val : $visit);)*)*
                        } deserializer.$deserialize(NonZeroVisitor)
                    }
                } #[cfg(not(no_core_num_saturating))] impl<'de>
                Deserialize<'de> for Saturating<$primitive>
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    {
                        struct SaturatingVisitor; impl<'de> Visitor<'de> for
                        SaturatingVisitor
                        {
                            type Value = Saturating<$primitive>; fn
                            expecting(&self, formatter: &mut fmt::Formatter) ->
                            fmt::Result
                            {
                                formatter.write_str("integer with support for saturating semantics")
                            } $($($method!(saturating $primitive $val : $visit);)*)*
                        } deserializer.$deserialize(SaturatingVisitor)
                    }
                }
            };
            ($primitive:ident, $deserialize:ident
            $($method:ident!($($val:ident : $visit:ident)*);)*) =>
            {
                impl<'de> Deserialize<'de> for $primitive
                {
                    #[inline] fn deserialize<D>(deserializer: D) -> Result<Self,
                    D::Error> where D: Deserializer<'de>,
                    {
                        struct PrimitiveVisitor; impl<'de> Visitor<'de> for
                        PrimitiveVisitor
                        {
                            type Value = $primitive; fn
                            expecting(&self, formatter: &mut fmt::Formatter) ->
                            fmt::Result { formatter.write_str(stringify!($primitive)) }
                            $($($method!($val : $visit);)*)*
                        } deserializer.$deserialize(PrimitiveVisitor)
                    }
                }
            };
        }
        macro_rules! num_self {
            ($ty:ident : $visit:ident) =>
            {
                #[inline] fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
                where E: Error, { Ok(v) }
            }; (nonzero $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if let Some(nonzero) = Self::Value::new(v) { Ok(nonzero) }
                    else
                    {
                        Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                    }
                }
            }; (saturating $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error, { Ok(Saturating(v)) }
            };
        }
        macro_rules! num_as_self {
            ($ty:ident : $visit:ident) =>
            {
                #[inline] fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
                where E: Error, { Ok(v as Self::Value) }
            }; (nonzero $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if let Some(nonzero) = Self::Value::new(v as $primitive)
                    { Ok(nonzero) } else
                    {
                        Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                    }
                }
            }; (saturating $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error, { Ok(Saturating(v as $primitive)) }
            };
        }
        macro_rules! num_as_copysign_self {
            ($ty:ident : $visit:ident) =>
            {
                #[inline] fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
                where E: Error,
                {
                    #[cfg(not(feature = "std"))] { Ok(v as Self::Value) }
                    #[cfg(feature = "std")]
                    {
                        let sign = if v.is_sign_positive() { 1.0 } else { -1.0 };
                        Ok((v as Self::Value).copysign(sign))
                    }
                }
            };
        }
        macro_rules! int_to_int {
            ($ty:ident : $visit:ident) =>
            {
                #[inline] fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
                where E: Error,
                {
                    Self::Value::try_from(v as
                    i64).map_err(|_|
                    Error::invalid_value(Unexpected::Signed(v as i64), &self))
                }
            }; (nonzero $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if let Ok(v) = $primitive::try_from(v as i64)
                    {
                        if let Some(nonzero) = Self::Value::new(v)
                        { return Ok(nonzero); }
                    }
                    Err(Error::invalid_value(Unexpected::Signed(v as i64),
                    &self))
                }
            }; (saturating $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if (v as i64) < $primitive::MIN as i64
                    { Ok(Saturating($primitive::MIN)) } else if
                    ($primitive::MAX as i64) < v as i64
                    { Ok(Saturating($primitive::MAX)) } else
                    { Ok(Saturating(v as $primitive)) }
                }
            };
        }
        macro_rules! int_to_uint {
            ($ty:ident : $visit:ident) =>
            {
                #[inline] fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
                where E: Error,
                {
                    if 0 <= v
                    {
                        #[allow(irrefutable_let_patterns)] if let Ok(v) =
                        Self::Value::try_from(v as u64)
                        { return Ok(v as Self::Value); }
                    }
                    Err(Error::invalid_value(Unexpected::Signed(v as i64),
                    &self))
                }
            }; (nonzero $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if 0 < v
                    {
                        #[allow(irrefutable_let_patterns)] if let Ok(v) =
                        $primitive::try_from(v as u64)
                        {
                            if let Some(nonzero) = Self::Value::new(v)
                            { return Ok(nonzero); }
                        }
                    }
                    Err(Error::invalid_value(Unexpected::Signed(v as i64),
                    &self))
                }
            }; (saturating $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if v < 0 { Ok(Saturating(0)) } else if
                    ($primitive::MAX as u64) < v as u64
                    { Ok(Saturating($primitive::MAX)) } else
                    { Ok(Saturating(v as $primitive)) }
                }
            };
        }
        macro_rules! uint_to_self {
            ($ty:ident : $visit:ident) =>
            {
                #[inline] fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
                where E: Error,
                {
                    Self::Value::try_from(v as
                    u64).map_err(|_|
                    Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                }
            }; (nonzero $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if let Ok(v) = $primitive::try_from(v as u64)
                    {
                        if let Some(nonzero) = Self::Value::new(v)
                        { return Ok(nonzero); }
                    }
                    Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                    &self))
                }
            }; (saturating $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if let Ok(v) = $primitive::try_from(v as u64)
                    { Ok(Saturating(v as $primitive)) } else
                    { Ok(Saturating($primitive::MAX)) }
                }
            };
        }
        impl<'de> Deserialize<'de> for i8 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = i8;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("i8")
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    i64).map_err(|_|
                                Error::invalid_value(Unexpected::Signed(v as i64), &self))
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    i64).map_err(|_|
                                Error::invalid_value(Unexpected::Signed(v as i64), &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    i64).map_err(|_|
                                Error::invalid_value(Unexpected::Signed(v as i64), &self))
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_i8(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroI8 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroI8;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero i8")
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as i64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as i64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as i64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = i8::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_i8(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<i8> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<i8>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i64) < i8::MIN as i64 {
                            Ok(Saturating(i8::MIN))
                        } else if (i8::MAX as i64) < v as i64 {
                            Ok(Saturating(i8::MAX))
                        } else { Ok(Saturating(v as i8)) }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i64) < i8::MIN as i64 {
                            Ok(Saturating(i8::MIN))
                        } else if (i8::MAX as i64) < v as i64 {
                            Ok(Saturating(i8::MAX))
                        } else { Ok(Saturating(v as i8)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i64) < i8::MIN as i64 {
                            Ok(Saturating(i8::MIN))
                        } else if (i8::MAX as i64) < v as i64 {
                            Ok(Saturating(i8::MAX))
                        } else { Ok(Saturating(v as i8)) }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = i8::try_from(v as u64) {
                            Ok(Saturating(v as i8))
                        } else { Ok(Saturating(i8::MAX)) }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as u64) {
                            Ok(Saturating(v as i8))
                        } else { Ok(Saturating(i8::MAX)) }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as u64) {
                            Ok(Saturating(v as i8))
                        } else { Ok(Saturating(i8::MAX)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i8::try_from(v as u64) {
                            Ok(Saturating(v as i8))
                        } else { Ok(Saturating(i8::MAX)) }
                    }
                }
                deserializer.deserialize_i8(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for i16 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = i16;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("i16")
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    i64).map_err(|_|
                                Error::invalid_value(Unexpected::Signed(v as i64), &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    i64).map_err(|_|
                                Error::invalid_value(Unexpected::Signed(v as i64), &self))
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_i16(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroI16 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroI16;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero i16")
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i16) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i16::try_from(v as i64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i16::try_from(v as i64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = i16::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i16::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i16::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i16::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_i16(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<i16> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<i16>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as i16))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i64) < i16::MIN as i64 {
                            Ok(Saturating(i16::MIN))
                        } else if (i16::MAX as i64) < v as i64 {
                            Ok(Saturating(i16::MAX))
                        } else { Ok(Saturating(v as i16)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i64) < i16::MIN as i64 {
                            Ok(Saturating(i16::MIN))
                        } else if (i16::MAX as i64) < v as i64 {
                            Ok(Saturating(i16::MAX))
                        } else { Ok(Saturating(v as i16)) }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = i16::try_from(v as u64) {
                            Ok(Saturating(v as i16))
                        } else { Ok(Saturating(i16::MAX)) }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i16::try_from(v as u64) {
                            Ok(Saturating(v as i16))
                        } else { Ok(Saturating(i16::MAX)) }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i16::try_from(v as u64) {
                            Ok(Saturating(v as i16))
                        } else { Ok(Saturating(i16::MAX)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i16::try_from(v as u64) {
                            Ok(Saturating(v as i16))
                        } else { Ok(Saturating(i16::MAX)) }
                    }
                }
                deserializer.deserialize_i16(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for i32 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = i32;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("i32")
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    i64).map_err(|_|
                                Error::invalid_value(Unexpected::Signed(v as i64), &self))
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_i32(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroI32 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroI32;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero i32")
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i32) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i32) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i32::try_from(v as i64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = i32::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i32::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i32::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i32::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_i32(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<i32> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<i32>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as i32))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i32))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i64) < i32::MIN as i64 {
                            Ok(Saturating(i32::MIN))
                        } else if (i32::MAX as i64) < v as i64 {
                            Ok(Saturating(i32::MAX))
                        } else { Ok(Saturating(v as i32)) }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = i32::try_from(v as u64) {
                            Ok(Saturating(v as i32))
                        } else { Ok(Saturating(i32::MAX)) }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i32::try_from(v as u64) {
                            Ok(Saturating(v as i32))
                        } else { Ok(Saturating(i32::MAX)) }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i32::try_from(v as u64) {
                            Ok(Saturating(v as i32))
                        } else { Ok(Saturating(i32::MAX)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i32::try_from(v as u64) {
                            Ok(Saturating(v as i32))
                        } else { Ok(Saturating(i32::MAX)) }
                    }
                }
                deserializer.deserialize_i32(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for i64 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = i64;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("i64")
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_i64(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroI64 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroI64;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero i64")
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i64) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i64) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i64) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = i64::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i64::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i64::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i64::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_i64(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<i64> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<i64>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as i64))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i64))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i64))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = i64::try_from(v as u64) {
                            Ok(Saturating(v as i64))
                        } else { Ok(Saturating(i64::MAX)) }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i64::try_from(v as u64) {
                            Ok(Saturating(v as i64))
                        } else { Ok(Saturating(i64::MAX)) }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i64::try_from(v as u64) {
                            Ok(Saturating(v as i64))
                        } else { Ok(Saturating(i64::MAX)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = i64::try_from(v as u64) {
                            Ok(Saturating(v as i64))
                        } else { Ok(Saturating(i64::MAX)) }
                    }
                }
                deserializer.deserialize_i64(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for isize {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = isize;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("isize")
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    i64).map_err(|_|
                                Error::invalid_value(Unexpected::Signed(v as i64), &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    i64).map_err(|_|
                                Error::invalid_value(Unexpected::Signed(v as i64), &self))
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_i64(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroIsize {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroIsize;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero isize")
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as isize) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as isize) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = isize::try_from(v as i64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = isize::try_from(v as i64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = isize::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = isize::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = isize::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = isize::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_i64(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<isize> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<isize>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as isize))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as isize))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i64) < isize::MIN as i64 {
                            Ok(Saturating(isize::MIN))
                        } else if (isize::MAX as i64) < v as i64 {
                            Ok(Saturating(isize::MAX))
                        } else { Ok(Saturating(v as isize)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i64) < isize::MIN as i64 {
                            Ok(Saturating(isize::MIN))
                        } else if (isize::MAX as i64) < v as i64 {
                            Ok(Saturating(isize::MAX))
                        } else { Ok(Saturating(v as isize)) }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Ok(v) = isize::try_from(v as u64) {
                            Ok(Saturating(v as isize))
                        } else { Ok(Saturating(isize::MAX)) }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = isize::try_from(v as u64) {
                            Ok(Saturating(v as isize))
                        } else { Ok(Saturating(isize::MAX)) }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = isize::try_from(v as u64) {
                            Ok(Saturating(v as isize))
                        } else { Ok(Saturating(isize::MAX)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = isize::try_from(v as u64) {
                            Ok(Saturating(v as isize))
                        } else { Ok(Saturating(isize::MAX)) }
                    }
                }
                deserializer.deserialize_i64(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for u8 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = u8;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("u8")
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_u8(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroU8 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroU8;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero u8")
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u8::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u8::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u8::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u8::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u8::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u8::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u8::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_u8(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<u8> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<u8>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u8::MAX as u64) < v as u64 {
                            Ok(Saturating(u8::MAX))
                        } else { Ok(Saturating(v as u8)) }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u8::MAX as u64) < v as u64 {
                            Ok(Saturating(u8::MAX))
                        } else { Ok(Saturating(v as u8)) }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u8::MAX as u64) < v as u64 {
                            Ok(Saturating(u8::MAX))
                        } else { Ok(Saturating(v as u8)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u8::MAX as u64) < v as u64 {
                            Ok(Saturating(u8::MAX))
                        } else { Ok(Saturating(v as u8)) }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u8::try_from(v as u64) {
                            Ok(Saturating(v as u8))
                        } else { Ok(Saturating(u8::MAX)) }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u8::try_from(v as u64) {
                            Ok(Saturating(v as u8))
                        } else { Ok(Saturating(u8::MAX)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u8::try_from(v as u64) {
                            Ok(Saturating(v as u8))
                        } else { Ok(Saturating(u8::MAX)) }
                    }
                }
                deserializer.deserialize_u8(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for u16 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = u16;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("u16")
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_u16(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroU16 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroU16;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero u16")
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u16) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u16::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u16::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u16::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u16::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u16::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u16::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_u16(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<u16> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<u16>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as u16))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u16::MAX as u64) < v as u64 {
                            Ok(Saturating(u16::MAX))
                        } else { Ok(Saturating(v as u16)) }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u16::MAX as u64) < v as u64 {
                            Ok(Saturating(u16::MAX))
                        } else { Ok(Saturating(v as u16)) }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u16::MAX as u64) < v as u64 {
                            Ok(Saturating(u16::MAX))
                        } else { Ok(Saturating(v as u16)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u16::MAX as u64) < v as u64 {
                            Ok(Saturating(u16::MAX))
                        } else { Ok(Saturating(v as u16)) }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u16::try_from(v as u64) {
                            Ok(Saturating(v as u16))
                        } else { Ok(Saturating(u16::MAX)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u16::try_from(v as u64) {
                            Ok(Saturating(v as u16))
                        } else { Ok(Saturating(u16::MAX)) }
                    }
                }
                deserializer.deserialize_u16(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for u32 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = u32;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("u32")
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_u32(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroU32 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroU32;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero u32")
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u32) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u32) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u32::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u32::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u32::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u32::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u32::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_u32(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<u32> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<u32>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as u32))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as u32))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u32::MAX as u64) < v as u64 {
                            Ok(Saturating(u32::MAX))
                        } else { Ok(Saturating(v as u32)) }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u32::MAX as u64) < v as u64 {
                            Ok(Saturating(u32::MAX))
                        } else { Ok(Saturating(v as u32)) }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u32::MAX as u64) < v as u64 {
                            Ok(Saturating(u32::MAX))
                        } else { Ok(Saturating(v as u32)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u32::MAX as u64) < v as u64 {
                            Ok(Saturating(u32::MAX))
                        } else { Ok(Saturating(v as u32)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = u32::try_from(v as u64) {
                            Ok(Saturating(v as u32))
                        } else { Ok(Saturating(u32::MAX)) }
                    }
                }
                deserializer.deserialize_u32(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for u64 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = u64;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("u64")
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                }
                deserializer.deserialize_u64(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroU64 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroU64;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero u64")
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u64) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u64) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u64) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u64::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u64::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u64::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u64::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                }
                deserializer.deserialize_u64(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<u64> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<u64>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as u64))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as u64))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as u64))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u64::MAX as u64) < v as u64 {
                            Ok(Saturating(u64::MAX))
                        } else { Ok(Saturating(v as u64)) }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u64::MAX as u64) < v as u64 {
                            Ok(Saturating(u64::MAX))
                        } else { Ok(Saturating(v as u64)) }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u64::MAX as u64) < v as u64 {
                            Ok(Saturating(u64::MAX))
                        } else { Ok(Saturating(v as u64)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u64::MAX as u64) < v as u64 {
                            Ok(Saturating(u64::MAX))
                        } else { Ok(Saturating(v as u64)) }
                    }
                }
                deserializer.deserialize_u64(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for usize {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = usize;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("usize")
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Self::Value::try_from(v as
                                    u64).map_err(|_|
                                Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
                    }
                }
                deserializer.deserialize_u64(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroUsize {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroUsize;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero usize")
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as usize) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as usize) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = usize::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = usize::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = usize::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = usize::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = usize::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = usize::try_from(v as u64) {
                            if let Some(nonzero) = Self::Value::new(v) {
                                return Ok(nonzero);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Unsigned(v as u64),
                                &self))
                    }
                }
                deserializer.deserialize_u64(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<usize> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<usize>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as usize))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as usize))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (usize::MAX as u64) < v as u64 {
                            Ok(Saturating(usize::MAX))
                        } else { Ok(Saturating(v as usize)) }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (usize::MAX as u64) < v as u64 {
                            Ok(Saturating(usize::MAX))
                        } else { Ok(Saturating(v as usize)) }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (usize::MAX as u64) < v as u64 {
                            Ok(Saturating(usize::MAX))
                        } else { Ok(Saturating(v as usize)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (usize::MAX as u64) < v as u64 {
                            Ok(Saturating(usize::MAX))
                        } else { Ok(Saturating(v as usize)) }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = usize::try_from(v as u64) {
                            Ok(Saturating(v as usize))
                        } else { Ok(Saturating(usize::MAX)) }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Ok(v) = usize::try_from(v as u64) {
                            Ok(Saturating(v as usize))
                        } else { Ok(Saturating(usize::MAX)) }
                    }
                }
                deserializer.deserialize_u64(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for f32 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = f32;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("f32")
                    }
                    #[inline]
                    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
                        where E: Error {
                        {
                            let sign = if v.is_sign_positive() { 1.0 } else { -1.0 };
                            Ok((v as Self::Value).copysign(sign))
                        }
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                }
                deserializer.deserialize_f32(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for f64 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = f64;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("f64")
                    }
                    #[inline]
                    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
                        where E: Error {
                        {
                            let sign = if v.is_sign_positive() { 1.0 } else { -1.0 };
                            Ok((v as Self::Value).copysign(sign))
                        }
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                }
                deserializer.deserialize_f64(PrimitiveVisitor)
            }
        }
        macro_rules! num_128 {
            ($ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if v as i128 >= Self::Value::MIN as i128 && v as u128 <=
                    Self::Value::MAX as u128 { Ok(v as Self::Value) } else
                    {
                        Err(Error::invalid_value(Unexpected::Other(stringify!($ty)),
                        &self,))
                    }
                }
            }; (nonzero $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if v as i128 >= $primitive::MIN as i128 && v as u128 <=
                    $primitive::MAX as u128
                    {
                        if let Some(nonzero) = Self::Value::new(v as $primitive)
                        { Ok(nonzero) } else
                        {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    } else
                    {
                        Err(Error::invalid_value(Unexpected::Other(stringify!($ty)),
                        &self,))
                    }
                }
            }; (saturating $primitive:ident $ty:ident : $visit:ident) =>
            {
                fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where E:
                Error,
                {
                    if (v as i128) < $primitive::MIN as i128
                    { Ok(Saturating($primitive::MIN)) } else if
                    ($primitive::MAX as u128) < v as u128
                    { Ok(Saturating($primitive::MAX)) } else
                    { Ok(Saturating(v as $primitive)) }
                }
            };
        }
        impl<'de> Deserialize<'de> for i128 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = i128;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("i128")
                    }
                    #[inline]
                    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
                        where E: Error {
                        if v as i128 >= Self::Value::MIN as i128 &&
                                v as u128 <= Self::Value::MAX as u128 {
                            Ok(v as Self::Value)
                        } else {
                            Err(Error::invalid_value(Unexpected::Other("u128"), &self))
                        }
                    }
                }
                deserializer.deserialize_i128(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroI128 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroI128;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero i128")
                    }
                    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as i128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
                        where E: Error {
                        if v as i128 >= i128::MIN as i128 &&
                                v as u128 <= i128::MAX as u128 {
                            if let Some(nonzero) = Self::Value::new(v as i128) {
                                Ok(nonzero)
                            } else {
                                Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                            }
                        } else {
                            Err(Error::invalid_value(Unexpected::Other("u128"), &self))
                        }
                    }
                }
                deserializer.deserialize_i128(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<i128> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<i128>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as i128))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i128))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i128))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i128))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as i128))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i128))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i128))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as i128))
                    }
                    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i128) < i128::MIN as i128 {
                            Ok(Saturating(i128::MIN))
                        } else if (i128::MAX as u128) < v as u128 {
                            Ok(Saturating(i128::MAX))
                        } else { Ok(Saturating(v as i128)) }
                    }
                }
                deserializer.deserialize_i128(SaturatingVisitor)
            }
        }
        impl<'de> Deserialize<'de> for u128 {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct PrimitiveVisitor;
                impl<'de> Visitor<'de> for PrimitiveVisitor {
                    type Value = u128;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("u128")
                    }
                    #[inline]
                    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v)
                    }
                    #[inline]
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(v as Self::Value)
                    }
                    #[inline]
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    #[inline]
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 <= v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = Self::Value::try_from(v as u64) {
                                return Ok(v as Self::Value);
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
                        where E: Error {
                        if v as i128 >= Self::Value::MIN as i128 &&
                                v as u128 <= Self::Value::MAX as u128 {
                            Ok(v as Self::Value)
                        } else {
                            Err(Error::invalid_value(Unexpected::Other("i128"), &self))
                        }
                    }
                }
                deserializer.deserialize_u128(PrimitiveVisitor)
            }
        }
        impl<'de> Deserialize<'de> for num::NonZeroU128 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct NonZeroVisitor;
                impl<'de> Visitor<'de> for NonZeroVisitor {
                    type Value = num::NonZeroU128;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a nonzero u128")
                    }
                    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        if let Some(nonzero) = Self::Value::new(v as u128) {
                            Ok(nonzero)
                        } else {
                            Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                        }
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u128::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u128::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u128::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if 0 < v {

                            #[allow(irrefutable_let_patterns)]
                            if let Ok(v) = u128::try_from(v as u64) {
                                if let Some(nonzero) = Self::Value::new(v) {
                                    return Ok(nonzero);
                                }
                            }
                        }
                        Err(Error::invalid_value(Unexpected::Signed(v as i64),
                                &self))
                    }
                    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
                        where E: Error {
                        if v as i128 >= u128::MIN as i128 &&
                                v as u128 <= u128::MAX as u128 {
                            if let Some(nonzero) = Self::Value::new(v as u128) {
                                Ok(nonzero)
                            } else {
                                Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                            }
                        } else {
                            Err(Error::invalid_value(Unexpected::Other("i128"), &self))
                        }
                    }
                }
                deserializer.deserialize_u128(NonZeroVisitor)
            }
        }
        impl<'de> Deserialize<'de> for Saturating<u128> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SaturatingVisitor;
                impl<'de> Visitor<'de> for SaturatingVisitor {
                    type Value = Saturating<u128>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("integer with support for saturating semantics")
                    }
                    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v))
                    }
                    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where
                        E: Error {
                        Ok(Saturating(v as u128))
                    }
                    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as u128))
                    }
                    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as u128))
                    }
                    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
                        where E: Error {
                        Ok(Saturating(v as u128))
                    }
                    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
                        E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u128::MAX as u64) < v as u64 {
                            Ok(Saturating(u128::MAX))
                        } else { Ok(Saturating(v as u128)) }
                    }
                    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u128::MAX as u64) < v as u64 {
                            Ok(Saturating(u128::MAX))
                        } else { Ok(Saturating(v as u128)) }
                    }
                    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u128::MAX as u64) < v as u64 {
                            Ok(Saturating(u128::MAX))
                        } else { Ok(Saturating(v as u128)) }
                    }
                    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
                        where E: Error {
                        if v < 0 {
                            Ok(Saturating(0))
                        } else if (u128::MAX as u64) < v as u64 {
                            Ok(Saturating(u128::MAX))
                        } else { Ok(Saturating(v as u128)) }
                    }
                    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
                        where E: Error {
                        if (v as i128) < u128::MIN as i128 {
                            Ok(Saturating(u128::MIN))
                        } else if (u128::MAX as u128) < v as u128 {
                            Ok(Saturating(u128::MAX))
                        } else { Ok(Saturating(v as u128)) }
                    }
                }
                deserializer.deserialize_u128(SaturatingVisitor)
            }
        }
        struct CharVisitor;
        impl<'de> Visitor<'de> for CharVisitor {
            type Value = char;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("a character")
            }
            #[inline]
            fn visit_char<E>(self, v: char) -> Result<Self::Value, E> where
                E: Error {
                Ok(v)
            }
            #[inline]
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where
                E: Error {
                let mut iter = v.chars();
                match (iter.next(), iter.next()) {
                    (Some(c), None) => Ok(c),
                    _ => Err(Error::invalid_value(Unexpected::Str(v), &self)),
                }
            }
        }
        impl<'de> Deserialize<'de> for char {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_char(CharVisitor)
            }
        }
        struct StringVisitor;
        struct StringInPlaceVisitor<'a>(&'a mut String);
        impl<'de> Visitor<'de> for StringVisitor {
            type Value = String;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("a string")
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where
                E: Error {
                Ok(v.to_owned())
            }
            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
                where E: Error {
                Ok(v)
            }
            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where
                E: Error {
                match str::from_utf8(v) {
                    Ok(s) => Ok(s.to_owned()),
                    Err(_) =>
                        Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
                }
            }
            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
                where E: Error {
                match String::from_utf8(v) {
                    Ok(s) => Ok(s),
                    Err(e) =>
                        Err(Error::invalid_value(Unexpected::Bytes(&e.into_bytes()),
                                &self)),
                }
            }
        }
        impl<'a, 'de> Visitor<'de> for StringInPlaceVisitor<'a> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("a string")
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where
                E: Error {
                self.0.clear();
                self.0.push_str(v);
                Ok(())
            }
            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
                where E: Error {
                *self.0 = v;
                Ok(())
            }
            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where
                E: Error {
                match str::from_utf8(v) {
                    Ok(s) => { self.0.clear(); self.0.push_str(s); Ok(()) }
                    Err(_) =>
                        Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
                }
            }
            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
                where E: Error {
                match String::from_utf8(v) {
                    Ok(s) => { *self.0 = s; Ok(()) }
                    Err(e) =>
                        Err(Error::invalid_value(Unexpected::Bytes(&e.into_bytes()),
                                &self)),
                }
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de> Deserialize<'de> for String {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_string(StringVisitor)
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_string(StringInPlaceVisitor(place))
            }
        }
        struct StrVisitor;
        impl<'a> Visitor<'a> for StrVisitor {
            type Value = &'a str;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("a borrowed string")
            }
            fn visit_borrowed_str<E>(self, v: &'a str)
                -> Result<Self::Value, E> where E: Error {
                Ok(v)
            }
            fn visit_borrowed_bytes<E>(self, v: &'a [u8])
                -> Result<Self::Value, E> where E: Error {
                str::from_utf8(v).map_err(|_|
                        Error::invalid_value(Unexpected::Bytes(v), &self))
            }
        }
        impl<'de: 'a, 'a> Deserialize<'de> for &'a str {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_str(StrVisitor)
            }
        }
        struct BytesVisitor;
        impl<'a> Visitor<'a> for BytesVisitor {
            type Value = &'a [u8];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("a borrowed byte array")
            }
            fn visit_borrowed_bytes<E>(self, v: &'a [u8])
                -> Result<Self::Value, E> where E: Error {
                Ok(v)
            }
            fn visit_borrowed_str<E>(self, v: &'a str)
                -> Result<Self::Value, E> where E: Error {
                Ok(v.as_bytes())
            }
        }
        impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_bytes(BytesVisitor)
            }
        }
        struct CStringVisitor;
        impl<'de> Visitor<'de> for CStringVisitor {
            type Value = CString;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("byte array")
            }
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let capacity = size_hint::cautious::<u8>(seq.size_hint());
                let mut values = Vec::<u8>::with_capacity(capacity);
                while let Some(value) =
                        match seq.next_element() {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        } {
                    values.push(value);
                }
                CString::new(values).map_err(Error::custom)
            }
            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where
                E: Error {
                CString::new(v).map_err(Error::custom)
            }
            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
                where E: Error {
                CString::new(v).map_err(Error::custom)
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where
                E: Error {
                CString::new(v).map_err(Error::custom)
            }
            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
                where E: Error {
                CString::new(v).map_err(Error::custom)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de> Deserialize<'de> for CString {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_byte_buf(CStringVisitor)
            }
        }
        macro_rules! forwarded_impl {
            ($(#[$attr:meta])* ($($id:ident),*), $ty:ty, $func:expr) =>
            {
                $(#[$attr])* impl<'de $(, $id : Deserialize<'de>,)*>
                Deserialize<'de> for $ty
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    { Deserialize::deserialize(deserializer).map($func) }
                }
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de> Deserialize<'de> for Box<CStr> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(CString::into_boxed_c_str)
            }
        }
        impl<'de, T: Deserialize<'de>> Deserialize<'de> for Reverse<T> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Reverse)
            }
        }
        struct OptionVisitor<T> {
            marker: PhantomData<T>,
        }
        impl<'de, T> Visitor<'de> for OptionVisitor<T> where
            T: Deserialize<'de> {
            type Value = Option<T>;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("option")
            }
            #[inline]
            fn visit_unit<E>(self) -> Result<Self::Value, E> where E: Error {
                Ok(None)
            }
            #[inline]
            fn visit_none<E>(self) -> Result<Self::Value, E> where E: Error {
                Ok(None)
            }
            #[inline]
            fn visit_some<D>(self, deserializer: D)
                -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
                T::deserialize(deserializer).map(Some)
            }
            fn __private_visit_untagged_option<D>(self, deserializer: D)
                -> Result<Self::Value, ()> where D: Deserializer<'de> {
                Ok(T::deserialize(deserializer).ok())
            }
        }
        impl<'de, T> Deserialize<'de> for Option<T> where T: Deserialize<'de>
            {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_option(OptionVisitor {
                        marker: PhantomData,
                    })
            }
        }
        struct PhantomDataVisitor<T: ?Sized> {
            marker: PhantomData<T>,
        }
        impl<'de, T> Visitor<'de> for PhantomDataVisitor<T> where T: ?Sized {
            type Value = PhantomData<T>;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("unit")
            }
            #[inline]
            fn visit_unit<E>(self) -> Result<Self::Value, E> where E: Error {
                Ok(PhantomData)
            }
        }
        impl<'de, T> Deserialize<'de> for PhantomData<T> where T: ?Sized {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                let visitor = PhantomDataVisitor { marker: PhantomData };
                deserializer.deserialize_unit_struct("PhantomData", visitor)
            }
        }
        macro_rules! seq_impl {
            ($(#[$attr:meta])* $ty:ident <T
            $(: $tbound1:ident $(+ $tbound2:ident)*)*
            $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
            $access:ident, $clear:expr, $with_capacity:expr, $reserve:expr,
            $insert:expr) =>
            {
                $(#[$attr])* impl<'de, T $(, $typaram)*> Deserialize<'de> for
                $ty<T $(, $typaram)*> where T: Deserialize<'de>
                $(+ $tbound1 $(+ $tbound2)*)*,
                $($typaram: $bound1 $(+ $bound2)*,)*
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    {
                        struct SeqVisitor<T $(, $typaram)*>
                        { marker: PhantomData<$ty<T $(, $typaram)*>>, } impl<'de, T
                        $(, $typaram)*> Visitor<'de> for SeqVisitor<T
                        $(, $typaram)*> where T: Deserialize<'de>
                        $(+ $tbound1 $(+ $tbound2)*)*,
                        $($typaram: $bound1 $(+ $bound2)*,)*
                        {
                            type Value = $ty<T $(, $typaram)*>; fn
                            expecting(&self, formatter: &mut fmt::Formatter) ->
                            fmt::Result { formatter.write_str("a sequence") } #[inline]
                            fn visit_seq<A>(self, mut $access: A) -> Result<Self::Value,
                            A::Error> where A: SeqAccess<'de>,
                            {
                                let mut values = $with_capacity; while let Some(value) =
                                tri!($access.next_element())
                                { $insert(&mut values, value); } Ok(values)
                            }
                        } let visitor = SeqVisitor { marker: PhantomData };
                        deserializer.deserialize_seq(visitor)
                    } fn
                    deserialize_in_place<D>(deserializer: D, place: &mut Self)
                    -> Result<(), D::Error> where D: Deserializer<'de>,
                    {
                        struct SeqInPlaceVisitor<'a, T: 'a
                        $(, $typaram: 'a)*>(&'a mut $ty<T $(, $typaram)*>); impl<'a,
                        'de, T $(, $typaram)*> Visitor<'de> for
                        SeqInPlaceVisitor<'a, T $(, $typaram)*> where T:
                        Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
                        $($typaram: $bound1 $(+ $bound2)*,)*
                        {
                            type Value = (); fn
                            expecting(&self, formatter: &mut fmt::Formatter) ->
                            fmt::Result { formatter.write_str("a sequence") } #[inline]
                            fn visit_seq<A>(mut self, mut $access: A) ->
                            Result<Self::Value, A::Error> where A: SeqAccess<'de>,
                            {
                                $clear(&mut self.0);
                                $reserve(&mut self.0,
                                size_hint::cautious::<T>($access.size_hint())); while let
                                Some(value) = tri!($access.next_element())
                                { $insert(&mut self.0, value); } Ok(())
                            }
                        } deserializer.deserialize_seq(SeqInPlaceVisitor(place))
                    }
                }
            }
        }
        fn nop_reserve<T>(_seq: T, _n: usize) {}
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T> Deserialize<'de> for BinaryHeap<T> where
            T: Deserialize<'de> + Ord {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SeqVisitor<T> {
                    marker: PhantomData<BinaryHeap<T>>,
                }
                impl<'de, T> Visitor<'de> for SeqVisitor<T> where
                    T: Deserialize<'de> + Ord {
                    type Value = BinaryHeap<T>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let mut values =
                            BinaryHeap::with_capacity(size_hint::cautious::<T>(seq.size_hint()));
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            BinaryHeap::push(&mut values, value);
                        }
                        Ok(values)
                    }
                }
                let visitor = SeqVisitor { marker: PhantomData };
                deserializer.deserialize_seq(visitor)
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct SeqInPlaceVisitor<'a, T: 'a>(&'a mut BinaryHeap<T>);
                impl<'a, 'de, T> Visitor<'de> for SeqInPlaceVisitor<'a, T>
                    where T: Deserialize<'de> + Ord {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(mut self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        BinaryHeap::clear(&mut self.0);
                        BinaryHeap::reserve(&mut self.0,
                            size_hint::cautious::<T>(seq.size_hint()));
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            BinaryHeap::push(&mut self.0, value);
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_seq(SeqInPlaceVisitor(place))
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T> Deserialize<'de> for BTreeSet<T> where
            T: Deserialize<'de> + Eq + Ord {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SeqVisitor<T> {
                    marker: PhantomData<BTreeSet<T>>,
                }
                impl<'de, T> Visitor<'de> for SeqVisitor<T> where
                    T: Deserialize<'de> + Eq + Ord {
                    type Value = BTreeSet<T>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let mut values = BTreeSet::new();
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            BTreeSet::insert(&mut values, value);
                        }
                        Ok(values)
                    }
                }
                let visitor = SeqVisitor { marker: PhantomData };
                deserializer.deserialize_seq(visitor)
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct SeqInPlaceVisitor<'a, T: 'a>(&'a mut BTreeSet<T>);
                impl<'a, 'de, T> Visitor<'de> for SeqInPlaceVisitor<'a, T>
                    where T: Deserialize<'de> + Eq + Ord {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(mut self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        BTreeSet::clear(&mut self.0);
                        nop_reserve(&mut self.0,
                            size_hint::cautious::<T>(seq.size_hint()));
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            BTreeSet::insert(&mut self.0, value);
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_seq(SeqInPlaceVisitor(place))
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T> Deserialize<'de> for LinkedList<T> where
            T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SeqVisitor<T> {
                    marker: PhantomData<LinkedList<T>>,
                }
                impl<'de, T> Visitor<'de> for SeqVisitor<T> where
                    T: Deserialize<'de> {
                    type Value = LinkedList<T>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let mut values = LinkedList::new();
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            LinkedList::push_back(&mut values, value);
                        }
                        Ok(values)
                    }
                }
                let visitor = SeqVisitor { marker: PhantomData };
                deserializer.deserialize_seq(visitor)
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct SeqInPlaceVisitor<'a, T: 'a>(&'a mut LinkedList<T>);
                impl<'a, 'de, T> Visitor<'de> for SeqInPlaceVisitor<'a, T>
                    where T: Deserialize<'de> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(mut self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        LinkedList::clear(&mut self.0);
                        nop_reserve(&mut self.0,
                            size_hint::cautious::<T>(seq.size_hint()));
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            LinkedList::push_back(&mut self.0, value);
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_seq(SeqInPlaceVisitor(place))
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de, T, S> Deserialize<'de> for HashSet<T, S> where
            T: Deserialize<'de> + Eq + Hash, S: BuildHasher + Default {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SeqVisitor<T, S> {
                    marker: PhantomData<HashSet<T, S>>,
                }
                impl<'de, T, S> Visitor<'de> for SeqVisitor<T, S> where
                    T: Deserialize<'de> + Eq + Hash, S: BuildHasher + Default {
                    type Value = HashSet<T, S>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let mut values =
                            HashSet::with_capacity_and_hasher(size_hint::cautious::<T>(seq.size_hint()),
                                S::default());
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            HashSet::insert(&mut values, value);
                        }
                        Ok(values)
                    }
                }
                let visitor = SeqVisitor { marker: PhantomData };
                deserializer.deserialize_seq(visitor)
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct SeqInPlaceVisitor<'a, T: 'a,
                    S: 'a>(&'a mut HashSet<T, S>);
                impl<'a, 'de, T, S> Visitor<'de> for
                    SeqInPlaceVisitor<'a, T, S> where T: Deserialize<'de> + Eq +
                    Hash, S: BuildHasher + Default {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(mut self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        HashSet::clear(&mut self.0);
                        HashSet::reserve(&mut self.0,
                            size_hint::cautious::<T>(seq.size_hint()));
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            HashSet::insert(&mut self.0, value);
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_seq(SeqInPlaceVisitor(place))
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T> Deserialize<'de> for VecDeque<T> where
            T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct SeqVisitor<T> {
                    marker: PhantomData<VecDeque<T>>,
                }
                impl<'de, T> Visitor<'de> for SeqVisitor<T> where
                    T: Deserialize<'de> {
                    type Value = VecDeque<T>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let mut values =
                            VecDeque::with_capacity(size_hint::cautious::<T>(seq.size_hint()));
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            VecDeque::push_back(&mut values, value);
                        }
                        Ok(values)
                    }
                }
                let visitor = SeqVisitor { marker: PhantomData };
                deserializer.deserialize_seq(visitor)
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct SeqInPlaceVisitor<'a, T: 'a>(&'a mut VecDeque<T>);
                impl<'a, 'de, T> Visitor<'de> for SeqInPlaceVisitor<'a, T>
                    where T: Deserialize<'de> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    #[inline]
                    fn visit_seq<A>(mut self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        VecDeque::clear(&mut self.0);
                        VecDeque::reserve(&mut self.0,
                            size_hint::cautious::<T>(seq.size_hint()));
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            VecDeque::push_back(&mut self.0, value);
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_seq(SeqInPlaceVisitor(place))
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T> Deserialize<'de> for Vec<T> where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct VecVisitor<T> {
                    marker: PhantomData<T>,
                }
                impl<'de, T> Visitor<'de> for VecVisitor<T> where
                    T: Deserialize<'de> {
                    type Value = Vec<T>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let capacity = size_hint::cautious::<T>(seq.size_hint());
                        let mut values = Vec::<T>::with_capacity(capacity);
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            values.push(value);
                        }
                        Ok(values)
                    }
                }
                let visitor = VecVisitor { marker: PhantomData };
                deserializer.deserialize_seq(visitor)
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct VecInPlaceVisitor<'a, T: 'a>(&'a mut Vec<T>);
                impl<'a, 'de, T> Visitor<'de> for VecInPlaceVisitor<'a, T>
                    where T: Deserialize<'de> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a sequence")
                    }
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let hint = size_hint::cautious::<T>(seq.size_hint());
                        if let Some(additional) = hint.checked_sub(self.0.len()) {
                            self.0.reserve(additional);
                        }
                        for i in 0..self.0.len() {
                            let next =
                                {
                                    let next_place = InPlaceSeed(&mut self.0[i]);
                                    match seq.next_element_seed(next_place) {
                                        Ok(val) => val,
                                        Err(err) => return Err(err),
                                    }
                                };
                            if next.is_none() { self.0.truncate(i); return Ok(()); }
                        }
                        while let Some(value) =
                                match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            self.0.push(value);
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_seq(VecInPlaceVisitor(place))
            }
        }
        struct ArrayVisitor<A> {
            marker: PhantomData<A>,
        }
        struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
        impl<A> ArrayVisitor<A> {
            fn new() -> Self { ArrayVisitor { marker: PhantomData } }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
            type Value = [T; 0];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an empty array")
            }
            #[inline]
            fn visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error> where
                A: SeqAccess<'de> {
                Ok([])
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 0] {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(0,
                    ArrayVisitor::<[T; 0]>::new())
            }
        }
        macro_rules! array_impls {
            ($($len:expr => ($($n:tt)+))+) =>
            {
                $(impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]> where
                T: Deserialize<'de>,
                {
                    type Value = [T; $len]; fn
                    expecting(&self, formatter: &mut fmt::Formatter) ->
                    fmt::Result
                    {
                        formatter.write_str(concat!("an array of length ", $len))
                    } #[inline] fn visit_seq<A>(self, mut seq: A) ->
                    Result<Self::Value, A::Error> where A: SeqAccess<'de>,
                    {
                        Ok([$(match tri!(seq.next_element())
                        {
                            Some(val) => val, None => return
                            Err(Error::invalid_length($n, &self)),
                        }),+])
                    }
                } impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a,
                [T; $len]> where T: Deserialize<'de>,
                {
                    type Value = (); fn
                    expecting(&self, formatter: &mut fmt::Formatter) ->
                    fmt::Result
                    {
                        formatter.write_str(concat!("an array of length ", $len))
                    } #[inline] fn visit_seq<A>(self, mut seq: A) ->
                    Result<Self::Value, A::Error> where A: SeqAccess<'de>,
                    {
                        let mut fail_idx = None; for (idx, dest) in
                        self.0[..].iter_mut().enumerate()
                        {
                            if tri!(seq.next_element_seed(InPlaceSeed(dest))).is_none()
                            { fail_idx = Some(idx); break; }
                        } if let Some(idx) = fail_idx
                        { return Err(Error::invalid_length(idx, &self)); } Ok(())
                    }
                } impl<'de, T> Deserialize<'de> for [T; $len] where T:
                Deserialize<'de>,
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    {
                        deserializer.deserialize_tuple($len,
                        ArrayVisitor::<[T; $len]>::new())
                    } fn
                    deserialize_in_place<D>(deserializer: D, place: &mut Self)
                    -> Result<(), D::Error> where D: Deserializer<'de>,
                    {
                        deserializer.deserialize_tuple($len,
                        ArrayInPlaceVisitor(place))
                    }
                })+
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 1]> where
            T: Deserialize<'de> {
            type Value = [T; 1];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 1")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 1]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 1")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 1] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(1,
                    ArrayVisitor::<[T; 1]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(1, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 2]> where
            T: Deserialize<'de> {
            type Value = [T; 2];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 2")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 2]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 2")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 2] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(2,
                    ArrayVisitor::<[T; 2]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(2, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 3]> where
            T: Deserialize<'de> {
            type Value = [T; 3];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 3")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 3]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 3")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 3] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(3,
                    ArrayVisitor::<[T; 3]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(3, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 4]> where
            T: Deserialize<'de> {
            type Value = [T; 4];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 4")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 4]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 4")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 4] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(4,
                    ArrayVisitor::<[T; 4]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(4, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 5]> where
            T: Deserialize<'de> {
            type Value = [T; 5];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 5")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 5]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 5")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 5] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(5,
                    ArrayVisitor::<[T; 5]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(5, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 6]> where
            T: Deserialize<'de> {
            type Value = [T; 6];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 6")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 6]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 6")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 6] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(6,
                    ArrayVisitor::<[T; 6]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(6, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 7]> where
            T: Deserialize<'de> {
            type Value = [T; 7];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 7")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 7]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 7")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 7] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(7,
                    ArrayVisitor::<[T; 7]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(7, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 8]> where
            T: Deserialize<'de> {
            type Value = [T; 8];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 8")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 8]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 8")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 8] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(8,
                    ArrayVisitor::<[T; 8]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(8, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 9]> where
            T: Deserialize<'de> {
            type Value = [T; 9];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 9")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 9]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 9")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 9] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(9,
                    ArrayVisitor::<[T; 9]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(9, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 10]> where
            T: Deserialize<'de> {
            type Value = [T; 10];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 10")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 10]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 10")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 10] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(10,
                    ArrayVisitor::<[T; 10]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(10, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 11]> where
            T: Deserialize<'de> {
            type Value = [T; 11];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 11")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 11]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 11")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 11] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(11,
                    ArrayVisitor::<[T; 11]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(11, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 12]> where
            T: Deserialize<'de> {
            type Value = [T; 12];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 12")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 12]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 12")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 12] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(12,
                    ArrayVisitor::<[T; 12]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(12, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 13]> where
            T: Deserialize<'de> {
            type Value = [T; 13];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 13")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 13]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 13")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 13] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(13,
                    ArrayVisitor::<[T; 13]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(13, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 14]> where
            T: Deserialize<'de> {
            type Value = [T; 14];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 14")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 14]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 14")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 14] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(14,
                    ArrayVisitor::<[T; 14]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(14, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 15]> where
            T: Deserialize<'de> {
            type Value = [T; 15];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 15")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 15]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 15")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 15] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(15,
                    ArrayVisitor::<[T; 15]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(15, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 16]> where
            T: Deserialize<'de> {
            type Value = [T; 16];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 16")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 16]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 16")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 16] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(16,
                    ArrayVisitor::<[T; 16]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(16, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 17]> where
            T: Deserialize<'de> {
            type Value = [T; 17];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 17")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 17]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 17")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 17] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(17,
                    ArrayVisitor::<[T; 17]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(17, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 18]> where
            T: Deserialize<'de> {
            type Value = [T; 18];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 18")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 18]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 18")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 18] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(18,
                    ArrayVisitor::<[T; 18]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(18, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 19]> where
            T: Deserialize<'de> {
            type Value = [T; 19];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 19")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 19]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 19")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 19] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(19,
                    ArrayVisitor::<[T; 19]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(19, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 20]> where
            T: Deserialize<'de> {
            type Value = [T; 20];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 20")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 20]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 20")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 20] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(20,
                    ArrayVisitor::<[T; 20]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(20, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 21]> where
            T: Deserialize<'de> {
            type Value = [T; 21];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 21")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 21]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 21")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 21] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(21,
                    ArrayVisitor::<[T; 21]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(21, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 22]> where
            T: Deserialize<'de> {
            type Value = [T; 22];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 22")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 22]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 22")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 22] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(22,
                    ArrayVisitor::<[T; 22]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(22, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 23]> where
            T: Deserialize<'de> {
            type Value = [T; 23];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 23")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 23]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 23")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 23] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(23,
                    ArrayVisitor::<[T; 23]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(23, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 24]> where
            T: Deserialize<'de> {
            type Value = [T; 24];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 24")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 24]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 24")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 24] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(24,
                    ArrayVisitor::<[T; 24]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(24, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 25]> where
            T: Deserialize<'de> {
            type Value = [T; 25];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 25")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(24, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 25]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 25")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 25] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(25,
                    ArrayVisitor::<[T; 25]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(25, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 26]> where
            T: Deserialize<'de> {
            type Value = [T; 26];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 26")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(24, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(25, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 26]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 26")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 26] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(26,
                    ArrayVisitor::<[T; 26]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(26, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 27]> where
            T: Deserialize<'de> {
            type Value = [T; 27];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 27")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(24, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(25, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(26, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 27]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 27")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 27] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(27,
                    ArrayVisitor::<[T; 27]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(27, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 28]> where
            T: Deserialize<'de> {
            type Value = [T; 28];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 28")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(24, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(25, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(26, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(27, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 28]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 28")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 28] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(28,
                    ArrayVisitor::<[T; 28]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(28, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 29]> where
            T: Deserialize<'de> {
            type Value = [T; 29];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 29")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(24, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(25, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(26, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(27, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(28, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 29]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 29")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 29] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(29,
                    ArrayVisitor::<[T; 29]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(29, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 30]> where
            T: Deserialize<'de> {
            type Value = [T; 30];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 30")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(24, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(25, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(26, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(27, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(28, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(29, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 30]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 30")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 30] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(30,
                    ArrayVisitor::<[T; 30]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(30, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 31]> where
            T: Deserialize<'de> {
            type Value = [T; 31];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 31")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(24, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(25, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(26, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(27, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(28, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(29, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(30, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 31]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 31")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 31] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(31,
                    ArrayVisitor::<[T; 31]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(31, ArrayInPlaceVisitor(place))
            }
        }
        impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 32]> where
            T: Deserialize<'de> {
            type Value = [T; 32];
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 32")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                Ok([match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(0, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(1, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(2, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(3, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(4, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(5, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(6, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(7, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(8, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(9, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(10, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(11, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(12, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(13, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(14, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(15, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(16, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(17, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(18, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(19, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(20, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(21, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(22, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(23, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(24, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(25, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(26, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(27, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(28, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(29, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(30, &self)),
                            },
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(val) => val,
                                None => return Err(Error::invalid_length(31, &self)),
                            }])
            }
        }
        impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; 32]>
            where T: Deserialize<'de> {
            type Value = ();
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("an array of length 32")
            }
            #[inline]
            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where A: SeqAccess<'de> {
                let mut fail_idx = None;
                for (idx, dest) in self.0[..].iter_mut().enumerate() {
                    if match seq.next_element_seed(InPlaceSeed(dest)) {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            }.is_none() {
                        fail_idx = Some(idx);
                        break;
                    }
                }
                if let Some(idx) = fail_idx {
                    return Err(Error::invalid_length(idx, &self));
                }
                Ok(())
            }
        }
        impl<'de, T> Deserialize<'de> for [T; 32] where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_tuple(32,
                    ArrayVisitor::<[T; 32]>::new())
            }
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                deserializer.deserialize_tuple(32, ArrayInPlaceVisitor(place))
            }
        }
        macro_rules! tuple_impls {
            ($($len:tt => ($($n:tt $name:ident)+))+) =>
            {
                $(#[cfg_attr(docsrs, doc(hidden))] impl<'de, $($name),+>
                Deserialize<'de> for ($($name,)+) where
                $($name: Deserialize<'de>,)+
                { tuple_impl_body!($len => ($($n $name)+)); })+
            };
        }
        macro_rules! tuple_impl_body {
            ($len:tt => ($($n:tt $name:ident)+)) =>
            {
                #[inline] fn deserialize<D>(deserializer: D) -> Result<Self,
                D::Error> where D: Deserializer<'de>,
                {
                    struct TupleVisitor<$($name,)+>
                    { marker: PhantomData<($($name,)+)>, } impl<'de,
                    $($name: Deserialize<'de>),+> Visitor<'de> for
                    TupleVisitor<$($name,)+>
                    {
                        type Value = ($($name,)+); fn
                        expecting(&self, formatter: &mut fmt::Formatter) ->
                        fmt::Result
                        { formatter.write_str(concat!("a tuple of size ", $len)) }
                        #[inline] #[allow(non_snake_case)] fn
                        visit_seq<A>(self, mut seq: A) -> Result<Self::Value,
                        A::Error> where A: SeqAccess<'de>,
                        {
                            $(let $name = match tri!(seq.next_element())
                            {
                                Some(value) => value, None => return
                                Err(Error::invalid_length($n, &self)),
                            };)+ Ok(($($name,)+))
                        }
                    }
                    deserializer.deserialize_tuple($len, TupleVisitor
                    { marker: PhantomData })
                } #[inline] fn
                deserialize_in_place<D>(deserializer: D, place: &mut Self) ->
                Result<(), D::Error> where D: Deserializer<'de>,
                {
                    struct TupleInPlaceVisitor<'a,
                    $($name: 'a,)+>(&'a mut ($($name,)+)); impl<'a, 'de,
                    $($name: Deserialize<'de>),+> Visitor<'de> for
                    TupleInPlaceVisitor<'a, $($name,)+>
                    {
                        type Value = (); fn
                        expecting(&self, formatter: &mut fmt::Formatter) ->
                        fmt::Result
                        { formatter.write_str(concat!("a tuple of size ", $len)) }
                        #[inline] #[allow(non_snake_case)] fn
                        visit_seq<A>(self, mut seq: A) -> Result<Self::Value,
                        A::Error> where A: SeqAccess<'de>,
                        {
                            $(if
                            tri!(seq.next_element_seed(InPlaceSeed(&mut
                            (self.0).$n))).is_none()
                            { return Err(Error::invalid_length($n, &self)); })+ Ok(())
                        }
                    }
                    deserializer.deserialize_tuple($len,
                    TupleInPlaceVisitor(place))
                }
            };
        }
        #[doc(fake_variadic)]
        #[doc = "This trait is implemented for tuples up to 16 items long."]
        impl<'de, T> Deserialize<'de> for (T,) where T: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T> {
                    marker: PhantomData<(T,)>,
                }
                impl<'de, T: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T> {
                    type Value = (T,);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 1")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        Ok((T,))
                    }
                }
                deserializer.deserialize_tuple(1,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T: 'a>(&'a mut (T,));
                impl<'a, 'de, T: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 1")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(1, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1> Deserialize<'de> for (T0, T1) where
            T0: Deserialize<'de>, T1: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1> {
                    marker: PhantomData<(T0, T1)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>>
                    Visitor<'de> for TupleVisitor<T0, T1> {
                    type Value = (T0, T1);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 2")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        Ok((T0, T1))
                    }
                }
                deserializer.deserialize_tuple(2,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a,
                    T1: 'a>(&'a mut (T0, T1));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>>
                    Visitor<'de> for TupleInPlaceVisitor<'a, T0, T1> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 2")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(2, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2> Deserialize<'de> for (T0, T1, T2) where
            T0: Deserialize<'de>, T1: Deserialize<'de>, T2: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2> {
                    marker: PhantomData<(T0, T1, T2)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2> {
                    type Value = (T0, T1, T2);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 3")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        Ok((T0, T1, T2))
                    }
                }
                deserializer.deserialize_tuple(3,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a,
                    T2: 'a>(&'a mut (T0, T1, T2));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 3")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(3, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3> Deserialize<'de> for (T0, T1, T2, T3) where
            T0: Deserialize<'de>, T1: Deserialize<'de>, T2: Deserialize<'de>,
            T3: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3> {
                    marker: PhantomData<(T0, T1, T2, T3)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3> {
                    type Value = (T0, T1, T2, T3);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 4")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        Ok((T0, T1, T2, T3))
                    }
                }
                deserializer.deserialize_tuple(4,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a,
                    T3: 'a>(&'a mut (T0, T1, T2, T3));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 4")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(4, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4> Deserialize<'de> for
            (T0, T1, T2, T3, T4) where T0: Deserialize<'de>,
            T1: Deserialize<'de>, T2: Deserialize<'de>, T3: Deserialize<'de>,
            T4: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4> {
                    marker: PhantomData<(T0, T1, T2, T3, T4)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4> {
                    type Value = (T0, T1, T2, T3, T4);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 5")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4))
                    }
                }
                deserializer.deserialize_tuple(5,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a>(&'a mut (T0, T1, T2, T3, T4));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 5")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(5, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5> Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5) where T0: Deserialize<'de>,
            T1: Deserialize<'de>, T2: Deserialize<'de>, T3: Deserialize<'de>,
            T4: Deserialize<'de>, T5: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4, T5> {
                    type Value = (T0, T1, T2, T3, T4, T5);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 6")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5))
                    }
                }
                deserializer.deserialize_tuple(6,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a>(&'a mut (T0, T1, T2, T3, T4, T5));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 6")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(6, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6> Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6) where T0: Deserialize<'de>,
            T1: Deserialize<'de>, T2: Deserialize<'de>, T3: Deserialize<'de>,
            T4: Deserialize<'de>, T5: Deserialize<'de>, T6: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6> {
                    type Value = (T0, T1, T2, T3, T4, T5, T6);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 7")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6))
                    }
                }
                deserializer.deserialize_tuple(7,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a,
                    T6: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 7")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(7, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7> Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6, T7) where T0: Deserialize<'de>,
            T1: Deserialize<'de>, T2: Deserialize<'de>, T3: Deserialize<'de>,
            T4: Deserialize<'de>, T5: Deserialize<'de>, T6: Deserialize<'de>,
            T7: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7> {
                    type Value = (T0, T1, T2, T3, T4, T5, T6, T7);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 8")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7))
                    }
                }
                deserializer.deserialize_tuple(8,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a,
                    T7: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 8")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(8, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8> Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8) where T0: Deserialize<'de>,
            T1: Deserialize<'de>, T2: Deserialize<'de>, T3: Deserialize<'de>,
            T4: Deserialize<'de>, T5: Deserialize<'de>, T6: Deserialize<'de>,
            T7: Deserialize<'de>, T8: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8> {
                    type Value = (T0, T1, T2, T3, T4, T5, T6, T7, T8);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 9")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        let T8 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(8, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7, T8))
                    }
                }
                deserializer.deserialize_tuple(9,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a, T7: 'a,
                    T8: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7, T8));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7, T8>
                    {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 9")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).8))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(8, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(9, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
            T0: Deserialize<'de>, T1: Deserialize<'de>, T2: Deserialize<'de>,
            T3: Deserialize<'de>, T4: Deserialize<'de>, T5: Deserialize<'de>,
            T6: Deserialize<'de>, T7: Deserialize<'de>, T8: Deserialize<'de>,
            T9: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7, T8,
                    T9)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
                    type Value = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 10")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        let T8 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(8, &self)),
                            };
                        let T9 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(9, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9))
                    }
                }
                deserializer.deserialize_tuple(10,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a,
                    T9: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7, T8,
                    T9> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 10")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).8))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(8, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).9))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(9, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(10, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
            Deserialize<'de> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
            where T0: Deserialize<'de>, T1: Deserialize<'de>,
            T2: Deserialize<'de>, T3: Deserialize<'de>, T4: Deserialize<'de>,
            T5: Deserialize<'de>, T6: Deserialize<'de>, T7: Deserialize<'de>,
            T8: Deserialize<'de>, T9: Deserialize<'de>, T10: Deserialize<'de>
            {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
                    type Value = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 11")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        let T8 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(8, &self)),
                            };
                        let T9 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(9, &self)),
                            };
                        let T10 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(10, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10))
                    }
                }
                deserializer.deserialize_tuple(11,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a,
                    T10: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7, T8,
                    T9, T10> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 11")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).8))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(8, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).9))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(9, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).10))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(10, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(11, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
            Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
            T0: Deserialize<'de>, T1: Deserialize<'de>, T2: Deserialize<'de>,
            T3: Deserialize<'de>, T4: Deserialize<'de>, T5: Deserialize<'de>,
            T6: Deserialize<'de>, T7: Deserialize<'de>, T8: Deserialize<'de>,
            T9: Deserialize<'de>, T10: Deserialize<'de>, T11: Deserialize<'de>
            {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>> Visitor<'de>
                    for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
                    T11> {
                    type Value =
                        (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 12")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        let T8 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(8, &self)),
                            };
                        let T9 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(9, &self)),
                            };
                        let T10 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(10, &self)),
                            };
                        let T11 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(11, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11))
                    }
                }
                deserializer.deserialize_tuple(12,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a,
                    T11: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>> Visitor<'de>
                    for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7, T8,
                    T9, T10, T11> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 12")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).8))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(8, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).9))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(9, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).10))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(10, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).11))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(11, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(12, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
            Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
            T0: Deserialize<'de>, T1: Deserialize<'de>, T2: Deserialize<'de>,
            T3: Deserialize<'de>, T4: Deserialize<'de>, T5: Deserialize<'de>,
            T6: Deserialize<'de>, T7: Deserialize<'de>, T8: Deserialize<'de>,
            T9: Deserialize<'de>, T10: Deserialize<'de>,
            T11: Deserialize<'de>, T12: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>,
                    T12: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
                    T11, T12> {
                    type Value =
                        (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 13")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        let T8 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(8, &self)),
                            };
                        let T9 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(9, &self)),
                            };
                        let T10 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(10, &self)),
                            };
                        let T11 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(11, &self)),
                            };
                        let T12 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(12, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12))
                    }
                }
                deserializer.deserialize_tuple(13,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a,
                    T11: 'a,
                    T12: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>,
                    T12: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7, T8,
                    T9, T10, T11, T12> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 13")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).8))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(8, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).9))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(9, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).10))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(10, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).11))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(11, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).12))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(12, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(13, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
            Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
            T0: Deserialize<'de>, T1: Deserialize<'de>, T2: Deserialize<'de>,
            T3: Deserialize<'de>, T4: Deserialize<'de>, T5: Deserialize<'de>,
            T6: Deserialize<'de>, T7: Deserialize<'de>, T8: Deserialize<'de>,
            T9: Deserialize<'de>, T10: Deserialize<'de>,
            T11: Deserialize<'de>, T12: Deserialize<'de>,
            T13: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>,
                    T12: Deserialize<'de>, T13: Deserialize<'de>> Visitor<'de>
                    for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
                    T11, T12, T13> {
                    type Value =
                        (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
                        T13);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 14")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        let T8 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(8, &self)),
                            };
                        let T9 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(9, &self)),
                            };
                        let T10 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(10, &self)),
                            };
                        let T11 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(11, &self)),
                            };
                        let T12 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(12, &self)),
                            };
                        let T13 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(13, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
                                T13))
                    }
                }
                deserializer.deserialize_tuple(14,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a,
                    T11: 'a, T12: 'a,
                    T13: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>,
                    T12: Deserialize<'de>, T13: Deserialize<'de>> Visitor<'de>
                    for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7, T8,
                    T9, T10, T11, T12, T13> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 14")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).8))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(8, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).9))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(9, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).10))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(10, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).11))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(11, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).12))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(12, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).13))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(13, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(14, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
            T14> Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
            where T0: Deserialize<'de>, T1: Deserialize<'de>,
            T2: Deserialize<'de>, T3: Deserialize<'de>, T4: Deserialize<'de>,
            T5: Deserialize<'de>, T6: Deserialize<'de>, T7: Deserialize<'de>,
            T8: Deserialize<'de>, T9: Deserialize<'de>, T10: Deserialize<'de>,
            T11: Deserialize<'de>, T12: Deserialize<'de>,
            T13: Deserialize<'de>, T14: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13, T14> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13, T14)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>,
                    T12: Deserialize<'de>, T13: Deserialize<'de>,
                    T14: Deserialize<'de>> Visitor<'de> for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
                    T11, T12, T13, T14> {
                    type Value =
                        (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
                        T14);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 15")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        let T8 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(8, &self)),
                            };
                        let T9 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(9, &self)),
                            };
                        let T10 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(10, &self)),
                            };
                        let T11 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(11, &self)),
                            };
                        let T12 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(12, &self)),
                            };
                        let T13 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(13, &self)),
                            };
                        let T14 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(14, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
                                T13, T14))
                    }
                }
                deserializer.deserialize_tuple(15,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a,
                    T11: 'a, T12: 'a, T13: 'a,
                    T14: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13, T14));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>,
                    T12: Deserialize<'de>, T13: Deserialize<'de>,
                    T14: Deserialize<'de>> Visitor<'de> for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7, T8,
                    T9, T10, T11, T12, T13, T14> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 15")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).8))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(8, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).9))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(9, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).10))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(10, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).11))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(11, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).12))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(12, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).13))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(13, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).14))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(14, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(15, TupleInPlaceVisitor(place))
            }
        }
        #[doc(hidden)]
        impl<'de, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
            T14, T15> Deserialize<'de> for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
            T15) where T0: Deserialize<'de>, T1: Deserialize<'de>,
            T2: Deserialize<'de>, T3: Deserialize<'de>, T4: Deserialize<'de>,
            T5: Deserialize<'de>, T6: Deserialize<'de>, T7: Deserialize<'de>,
            T8: Deserialize<'de>, T9: Deserialize<'de>, T10: Deserialize<'de>,
            T11: Deserialize<'de>, T12: Deserialize<'de>,
            T13: Deserialize<'de>, T14: Deserialize<'de>,
            T15: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13, T14, T15> {
                    marker: PhantomData<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13, T14, T15)>,
                }
                impl<'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>,
                    T12: Deserialize<'de>, T13: Deserialize<'de>,
                    T14: Deserialize<'de>, T15: Deserialize<'de>> Visitor<'de>
                    for
                    TupleVisitor<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
                    T11, T12, T13, T14, T15> {
                    type Value =
                        (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
                        T14, T15);
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 16")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let T0 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(0, &self)),
                            };
                        let T1 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(1, &self)),
                            };
                        let T2 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(2, &self)),
                            };
                        let T3 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(3, &self)),
                            };
                        let T4 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(4, &self)),
                            };
                        let T5 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(5, &self)),
                            };
                        let T6 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(6, &self)),
                            };
                        let T7 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(7, &self)),
                            };
                        let T8 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(8, &self)),
                            };
                        let T9 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(9, &self)),
                            };
                        let T10 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(10, &self)),
                            };
                        let T11 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(11, &self)),
                            };
                        let T12 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(12, &self)),
                            };
                        let T13 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(13, &self)),
                            };
                        let T14 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(14, &self)),
                            };
                        let T15 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => return Err(Error::invalid_length(15, &self)),
                            };
                        Ok((T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
                                T13, T14, T15))
                    }
                }
                deserializer.deserialize_tuple(16,
                    TupleVisitor { marker: PhantomData })
            }
            #[inline]
            fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
                -> Result<(), D::Error> where D: Deserializer<'de> {
                struct TupleInPlaceVisitor<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a,
                    T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a,
                    T11: 'a, T12: 'a, T13: 'a, T14: 'a,
                    T15: 'a>(&'a mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
                    T10, T11, T12, T13, T14, T15));
                impl<'a, 'de, T0: Deserialize<'de>, T1: Deserialize<'de>,
                    T2: Deserialize<'de>, T3: Deserialize<'de>,
                    T4: Deserialize<'de>, T5: Deserialize<'de>,
                    T6: Deserialize<'de>, T7: Deserialize<'de>,
                    T8: Deserialize<'de>, T9: Deserialize<'de>,
                    T10: Deserialize<'de>, T11: Deserialize<'de>,
                    T12: Deserialize<'de>, T13: Deserialize<'de>,
                    T14: Deserialize<'de>, T15: Deserialize<'de>> Visitor<'de>
                    for
                    TupleInPlaceVisitor<'a, T0, T1, T2, T3, T4, T5, T6, T7, T8,
                    T9, T10, T11, T12, T13, T14, T15> {
                    type Value = ();
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a tuple of size 16")
                    }
                    #[inline]
                    #[allow(non_snake_case)]
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).0))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(0, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).1))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(1, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).2))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(2, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).3))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(3, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).4))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(4, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).5))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(5, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).6))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(6, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).7))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(7, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).8))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(8, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).9))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(9, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).10))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(10, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).11))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(11, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).12))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(12, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).13))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(13, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).14))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(14, &self));
                        }
                        if match seq.next_element_seed(InPlaceSeed(&mut (self.0).15))
                                    {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                }.is_none() {
                            return Err(Error::invalid_length(15, &self));
                        }
                        Ok(())
                    }
                }
                deserializer.deserialize_tuple(16, TupleInPlaceVisitor(place))
            }
        }
        macro_rules! map_impl {
            ($(#[$attr:meta])* $ty:ident <K
            $(: $kbound1:ident $(+ $kbound2:ident)*)*, V
            $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
            $access:ident, $with_capacity:expr,) =>
            {
                $(#[$attr])* impl<'de, K, V $(, $typaram)*> Deserialize<'de>
                for $ty<K, V $(, $typaram)*> where K: Deserialize<'de>
                $(+ $kbound1 $(+ $kbound2)*)*, V: Deserialize<'de>,
                $($typaram: $bound1 $(+ $bound2)*),*
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    {
                        struct MapVisitor<K, V $(, $typaram)*>
                        { marker: PhantomData<$ty<K, V $(, $typaram)*>>, } impl<'de,
                        K, V $(, $typaram)*> Visitor<'de> for MapVisitor<K, V
                        $(, $typaram)*> where K: Deserialize<'de>
                        $(+ $kbound1 $(+ $kbound2)*)*, V: Deserialize<'de>,
                        $($typaram: $bound1 $(+ $bound2)*),*
                        {
                            type Value = $ty<K, V $(, $typaram)*>; fn
                            expecting(&self, formatter: &mut fmt::Formatter) ->
                            fmt::Result { formatter.write_str("a map") } #[inline] fn
                            visit_map<A>(self, mut $access: A) -> Result<Self::Value,
                            A::Error> where A: MapAccess<'de>,
                            {
                                let mut values = $with_capacity; while let
                                Some((key, value)) = tri!($access.next_entry())
                                { values.insert(key, value); } Ok(values)
                            }
                        } let visitor = MapVisitor { marker: PhantomData };
                        deserializer.deserialize_map(visitor)
                    }
                }
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, K, V> Deserialize<'de> for BTreeMap<K, V> where
            K: Deserialize<'de> + Ord, V: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct MapVisitor<K, V> {
                    marker: PhantomData<BTreeMap<K, V>>,
                }
                impl<'de, K, V> Visitor<'de> for MapVisitor<K, V> where
                    K: Deserialize<'de> + Ord, V: Deserialize<'de> {
                    type Value = BTreeMap<K, V>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a map")
                    }
                    #[inline]
                    fn visit_map<A>(self, mut map: A)
                        -> Result<Self::Value, A::Error> where A: MapAccess<'de> {
                        let mut values = BTreeMap::new();
                        while let Some((key, value)) =
                                match map.next_entry() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            values.insert(key, value);
                        }
                        Ok(values)
                    }
                }
                let visitor = MapVisitor { marker: PhantomData };
                deserializer.deserialize_map(visitor)
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de, K, V, S> Deserialize<'de> for HashMap<K, V, S> where
            K: Deserialize<'de> + Eq + Hash, V: Deserialize<'de>,
            S: BuildHasher + Default {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct MapVisitor<K, V, S> {
                    marker: PhantomData<HashMap<K, V, S>>,
                }
                impl<'de, K, V, S> Visitor<'de> for MapVisitor<K, V, S> where
                    K: Deserialize<'de> + Eq + Hash, V: Deserialize<'de>,
                    S: BuildHasher + Default {
                    type Value = HashMap<K, V, S>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("a map")
                    }
                    #[inline]
                    fn visit_map<A>(self, mut map: A)
                        -> Result<Self::Value, A::Error> where A: MapAccess<'de> {
                        let mut values =
                            HashMap::with_capacity_and_hasher(size_hint::cautious::<(K,
                                        V)>(map.size_hint()), S::default());
                        while let Some((key, value)) =
                                match map.next_entry() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            values.insert(key, value);
                        }
                        Ok(values)
                    }
                }
                let visitor = MapVisitor { marker: PhantomData };
                deserializer.deserialize_map(visitor)
            }
        }
        macro_rules! parse_ip_impl {
            ($ty:ty, $expecting:expr, $size:tt) =>
            {
                impl<'de> Deserialize<'de> for $ty
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    {
                        if deserializer.is_human_readable()
                        {
                            deserializer.deserialize_str(FromStrVisitor::new($expecting))
                        } else
                        {
                            <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
                        }
                    }
                }
            };
        }
        macro_rules! variant_identifier {
            ($name_kind:ident($($variant:ident; $bytes:expr; $index:expr),*)
            $expecting_message:expr, $variants_name:ident) =>
            {
                enum $name_kind { $($variant),* } static $variants_name:
                &[&str] = &[$(stringify!($variant)),*]; impl<'de>
                Deserialize<'de> for $name_kind
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    {
                        struct KindVisitor; impl<'de> Visitor<'de> for KindVisitor
                        {
                            type Value = $name_kind; fn
                            expecting(&self, formatter: &mut fmt::Formatter) ->
                            fmt::Result { formatter.write_str($expecting_message) } fn
                            visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                            where E: Error,
                            {
                                match value
                                {
                                    $($index => Ok($name_kind :: $variant),)* _ =>
                                    Err(Error::invalid_value(Unexpected::Unsigned(value),
                                    &self),),
                                }
                            } fn visit_str<E>(self, value: &str) -> Result<Self::Value,
                            E> where E: Error,
                            {
                                match value
                                {
                                    $(stringify!($variant) => Ok($name_kind :: $variant),)* _ =>
                                    Err(Error::unknown_variant(value, $variants_name)),
                                }
                            } fn visit_bytes<E>(self, value: &[u8]) ->
                            Result<Self::Value, E> where E: Error,
                            {
                                match value
                                {
                                    $($bytes => Ok($name_kind :: $variant),)* _ =>
                                    {
                                        match str::from_utf8(value)
                                        {
                                            Ok(value) =>
                                            Err(Error::unknown_variant(value, $variants_name)), Err(_)
                                            =>
                                            Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
                                        }
                                    }
                                }
                            }
                        } deserializer.deserialize_identifier(KindVisitor)
                    }
                }
            }
        }
        macro_rules! deserialize_enum {
            ($name:ident
            $name_kind:ident($($variant:ident; $bytes:expr; $index:expr),*)
            $expecting_message:expr, $deserializer:expr) =>
            {
                variant_identifier!
                {
                    $name_kind($($variant; $bytes; $index),*)
                    $expecting_message, VARIANTS
                } struct EnumVisitor; impl<'de> Visitor<'de> for EnumVisitor
                {
                    type Value = $name; fn
                    expecting(&self, formatter: &mut fmt::Formatter) ->
                    fmt::Result
                    { formatter.write_str(concat!("a ", stringify!($name))) } fn
                    visit_enum<A>(self, data: A) -> Result<Self::Value,
                    A::Error> where A: EnumAccess<'de>,
                    {
                        match tri!(data.variant())
                        {
                            $(($name_kind :: $variant, v) =>
                            v.newtype_variant().map($name :: $variant),)*
                        }
                    }
                }
                $deserializer.deserialize_enum(stringify!($name), VARIANTS,
                EnumVisitor)
            }
        }
        impl<'de> Deserialize<'de> for net::IpAddr {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                if deserializer.is_human_readable() {
                    deserializer.deserialize_str(FromStrVisitor::new("IP address"))
                } else {
                    use crate::lib::net::IpAddr;
                    enum IpAddrKind { V4, V6, }
                    static VARIANTS: &[&str] = &["V4", "V6"];
                    impl<'de> Deserialize<'de> for IpAddrKind {
                        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                            where D: Deserializer<'de> {
                            struct KindVisitor;
                            impl<'de> Visitor<'de> for KindVisitor {
                                type Value = IpAddrKind;
                                fn expecting(&self, formatter: &mut fmt::Formatter)
                                    -> fmt::Result {
                                    formatter.write_str("`V4` or `V6`")
                                }
                                fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                                    where E: Error {
                                    match value {
                                        0 => Ok(IpAddrKind::V4),
                                        1 => Ok(IpAddrKind::V6),
                                        _ =>
                                            Err(Error::invalid_value(Unexpected::Unsigned(value),
                                                    &self)),
                                    }
                                }
                                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                                    where E: Error {
                                    match value {
                                        "V4" => Ok(IpAddrKind::V4),
                                        "V6" => Ok(IpAddrKind::V6),
                                        _ => Err(Error::unknown_variant(value, VARIANTS)),
                                    }
                                }
                                fn visit_bytes<E>(self, value: &[u8])
                                    -> Result<Self::Value, E> where E: Error {
                                    match value {
                                        b"V4" => Ok(IpAddrKind::V4),
                                        b"V6" => Ok(IpAddrKind::V6),
                                        _ => {
                                            match str::from_utf8(value) {
                                                Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
                                                Err(_) =>
                                                    Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
                                            }
                                        }
                                    }
                                }
                            }
                            deserializer.deserialize_identifier(KindVisitor)
                        }
                    }
                    struct EnumVisitor;
                    impl<'de> Visitor<'de> for EnumVisitor {
                        type Value = IpAddr;
                        fn expecting(&self, formatter: &mut fmt::Formatter)
                            -> fmt::Result {
                            formatter.write_str("a IpAddr")
                        }
                        fn visit_enum<A>(self, data: A)
                            -> Result<Self::Value, A::Error> where A: EnumAccess<'de> {
                            match match data.variant() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                (IpAddrKind::V4, v) => v.newtype_variant().map(IpAddr::V4),
                                (IpAddrKind::V6, v) => v.newtype_variant().map(IpAddr::V6),
                            }
                        }
                    }
                    deserializer.deserialize_enum("IpAddr", VARIANTS,
                        EnumVisitor)
                }
            }
        }
        impl<'de> Deserialize<'de> for net::Ipv4Addr {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                if deserializer.is_human_readable() {
                    deserializer.deserialize_str(FromStrVisitor::new("IPv4 address"))
                } else {
                    <[u8; 4]>::deserialize(deserializer).map(<net::Ipv4Addr>::from)
                }
            }
        }
        impl<'de> Deserialize<'de> for net::Ipv6Addr {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                if deserializer.is_human_readable() {
                    deserializer.deserialize_str(FromStrVisitor::new("IPv6 address"))
                } else {
                    <[u8; 16]>::deserialize(deserializer).map(<net::Ipv6Addr>::from)
                }
            }
        }
        macro_rules! parse_socket_impl {
            ($ty:ty, $expecting:tt, $new:expr,) =>
            {
                impl<'de> Deserialize<'de> for $ty
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    {
                        if deserializer.is_human_readable()
                        {
                            deserializer.deserialize_str(FromStrVisitor::new($expecting))
                        } else { <(_, u16)>::deserialize(deserializer).map($new) }
                    }
                }
            };
        }
        impl<'de> Deserialize<'de> for net::SocketAddr {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                if deserializer.is_human_readable() {
                    deserializer.deserialize_str(FromStrVisitor::new("socket address"))
                } else {
                    use crate::lib::net::SocketAddr;
                    enum SocketAddrKind { V4, V6, }
                    static VARIANTS: &[&str] = &["V4", "V6"];
                    impl<'de> Deserialize<'de> for SocketAddrKind {
                        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                            where D: Deserializer<'de> {
                            struct KindVisitor;
                            impl<'de> Visitor<'de> for KindVisitor {
                                type Value = SocketAddrKind;
                                fn expecting(&self, formatter: &mut fmt::Formatter)
                                    -> fmt::Result {
                                    formatter.write_str("`V4` or `V6`")
                                }
                                fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                                    where E: Error {
                                    match value {
                                        0 => Ok(SocketAddrKind::V4),
                                        1 => Ok(SocketAddrKind::V6),
                                        _ =>
                                            Err(Error::invalid_value(Unexpected::Unsigned(value),
                                                    &self)),
                                    }
                                }
                                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                                    where E: Error {
                                    match value {
                                        "V4" => Ok(SocketAddrKind::V4),
                                        "V6" => Ok(SocketAddrKind::V6),
                                        _ => Err(Error::unknown_variant(value, VARIANTS)),
                                    }
                                }
                                fn visit_bytes<E>(self, value: &[u8])
                                    -> Result<Self::Value, E> where E: Error {
                                    match value {
                                        b"V4" => Ok(SocketAddrKind::V4),
                                        b"V6" => Ok(SocketAddrKind::V6),
                                        _ => {
                                            match str::from_utf8(value) {
                                                Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
                                                Err(_) =>
                                                    Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
                                            }
                                        }
                                    }
                                }
                            }
                            deserializer.deserialize_identifier(KindVisitor)
                        }
                    }
                    struct EnumVisitor;
                    impl<'de> Visitor<'de> for EnumVisitor {
                        type Value = SocketAddr;
                        fn expecting(&self, formatter: &mut fmt::Formatter)
                            -> fmt::Result {
                            formatter.write_str("a SocketAddr")
                        }
                        fn visit_enum<A>(self, data: A)
                            -> Result<Self::Value, A::Error> where A: EnumAccess<'de> {
                            match match data.variant() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                (SocketAddrKind::V4, v) =>
                                    v.newtype_variant().map(SocketAddr::V4),
                                (SocketAddrKind::V6, v) =>
                                    v.newtype_variant().map(SocketAddr::V6),
                            }
                        }
                    }
                    deserializer.deserialize_enum("SocketAddr", VARIANTS,
                        EnumVisitor)
                }
            }
        }
        impl<'de> Deserialize<'de> for net::SocketAddrV4 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                if deserializer.is_human_readable() {
                    deserializer.deserialize_str(FromStrVisitor::new("IPv4 socket address"))
                } else {
                    <(_,
                                u16)>::deserialize(deserializer).map(|(ip, port)|
                            net::SocketAddrV4::new(ip, port))
                }
            }
        }
        impl<'de> Deserialize<'de> for net::SocketAddrV6 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                if deserializer.is_human_readable() {
                    deserializer.deserialize_str(FromStrVisitor::new("IPv6 socket address"))
                } else {
                    <(_,
                                u16)>::deserialize(deserializer).map(|(ip, port)|
                            net::SocketAddrV6::new(ip, port, 0, 0))
                }
            }
        }
        struct PathVisitor;
        impl<'a> Visitor<'a> for PathVisitor {
            type Value = &'a Path;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("a borrowed path")
            }
            fn visit_borrowed_str<E>(self, v: &'a str)
                -> Result<Self::Value, E> where E: Error {
                Ok(v.as_ref())
            }
            fn visit_borrowed_bytes<E>(self, v: &'a [u8])
                -> Result<Self::Value, E> where E: Error {
                str::from_utf8(v).map(AsRef::as_ref).map_err(|_|
                        Error::invalid_value(Unexpected::Bytes(v), &self))
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_str(PathVisitor)
            }
        }
        struct PathBufVisitor;
        impl<'de> Visitor<'de> for PathBufVisitor {
            type Value = PathBuf;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("path string")
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where
                E: Error {
                Ok(From::from(v))
            }
            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
                where E: Error {
                Ok(From::from(v))
            }
            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where
                E: Error {
                str::from_utf8(v).map(From::from).map_err(|_|
                        Error::invalid_value(Unexpected::Bytes(v), &self))
            }
            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
                where E: Error {
                String::from_utf8(v).map(From::from).map_err(|e|
                        Error::invalid_value(Unexpected::Bytes(&e.into_bytes()),
                            &self))
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de> Deserialize<'de> for PathBuf {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_string(PathBufVisitor)
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de> Deserialize<'de> for Box<Path> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(PathBuf::into_boxed_path)
            }
        }
        enum OsStringKind { Unix, Windows, }
        static OSSTR_VARIANTS: &[&str] = &["Unix", "Windows"];
        impl<'de> Deserialize<'de> for OsStringKind {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                struct KindVisitor;
                impl<'de> Visitor<'de> for KindVisitor {
                    type Value = OsStringKind;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("`Unix` or `Windows`")
                    }
                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                        where E: Error {
                        match value {
                            0 => Ok(OsStringKind::Unix),
                            1 => Ok(OsStringKind::Windows),
                            _ =>
                                Err(Error::invalid_value(Unexpected::Unsigned(value),
                                        &self)),
                        }
                    }
                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                        where E: Error {
                        match value {
                            "Unix" => Ok(OsStringKind::Unix),
                            "Windows" => Ok(OsStringKind::Windows),
                            _ => Err(Error::unknown_variant(value, OSSTR_VARIANTS)),
                        }
                    }
                    fn visit_bytes<E>(self, value: &[u8])
                        -> Result<Self::Value, E> where E: Error {
                        match value {
                            b"Unix" => Ok(OsStringKind::Unix),
                            b"Windows" => Ok(OsStringKind::Windows),
                            _ => {
                                match str::from_utf8(value) {
                                    Ok(value) =>
                                        Err(Error::unknown_variant(value, OSSTR_VARIANTS)),
                                    Err(_) =>
                                        Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
                                }
                            }
                        }
                    }
                }
                deserializer.deserialize_identifier(KindVisitor)
            }
        }
        struct OsStringVisitor;
        impl<'de> Visitor<'de> for OsStringVisitor {
            type Value = OsString;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str("os string")
            }
            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
                where A: EnumAccess<'de> {
                use std::os::unix::ffi::OsStringExt;
                match match data.variant() {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    } {
                    (OsStringKind::Unix, v) =>
                        v.newtype_variant().map(OsString::from_vec),
                    (OsStringKind::Windows, _) =>
                        Err(Error::custom("cannot deserialize Windows OS string on Unix")),
                }
            }
        }
        #[doc(cfg(all(feature = "std", any(unix, windows))))]
        impl<'de> Deserialize<'de> for OsString {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                deserializer.deserialize_enum("OsString", OSSTR_VARIANTS,
                    OsStringVisitor)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<T> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Box::new)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, T: Deserialize<'de>> Deserialize<'de> for Box<[T]> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Vec::into_boxed_slice)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de> Deserialize<'de> for Box<str> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(String::into_boxed_str)
            }
        }
        #[doc(cfg(all(feature = "std", any(unix, windows))))]
        impl<'de> Deserialize<'de> for Box<OsStr> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(OsString::into_boxed_os_str)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'de, 'a, T> Deserialize<'de> for Cow<'a, T> where T: ?Sized +
            ToOwned, T::Owned: Deserialize<'de> {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                T::Owned::deserialize(deserializer).map(Cow::Owned)
            }
        }
        /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
        /// `Weak<T>` has a reference count of 0 and cannot be upgraded.
        ///
        /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
        #[doc(cfg(all(feature = "rc",
        any(feature = "std", feature = "alloc"))))]
        impl<'de, T> Deserialize<'de> for RcWeak<T> where T: Deserialize<'de>
            {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                match Option::<T>::deserialize(deserializer) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                Ok(RcWeak::new())
            }
        }
        /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
        /// `Weak<T>` has a reference count of 0 and cannot be upgraded.
        ///
        /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
        #[doc(cfg(all(feature = "rc",
        any(feature = "std", feature = "alloc"))))]
        impl<'de, T> Deserialize<'de> for ArcWeak<T> where T: Deserialize<'de>
            {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                match Option::<T>::deserialize(deserializer) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                Ok(ArcWeak::new())
            }
        }
        macro_rules! box_forwarded_impl {
            ($(#[$attr:meta])* $t:ident) =>
            {
                $(#[$attr])* impl<'de, T> Deserialize<'de> for $t<T> where T:
                ?Sized, Box<T>: Deserialize<'de>,
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    { Box::deserialize(deserializer).map(Into::into) }
                }
            };
        }
        #[doc = r#" This impl requires the [`"rc"`] Cargo feature of Serde."#]
        #[doc = r""]
        #[doc =
        r" Deserializing a data structure containing `Rc` will not attempt to"]
        #[doc =
        r" deduplicate `Rc` references to the same data. Every deserialized `Rc`"]
        #[doc = r" will end up with a strong count of 1."]
        #[doc = r""]
        #[doc =
        r#" [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc"#]
        #[doc(cfg(all(feature = "rc",
        any(feature = "std", feature = "alloc"))))]
        impl<'de, T> Deserialize<'de> for Rc<T> where T: ?Sized,
            Box<T>: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Box::deserialize(deserializer).map(Into::into)
            }
        }
        #[doc = r#" This impl requires the [`"rc"`] Cargo feature of Serde."#]
        #[doc = r""]
        #[doc =
        r" Deserializing a data structure containing `Arc` will not attempt to"]
        #[doc =
        r" deduplicate `Arc` references to the same data. Every deserialized `Arc`"]
        #[doc = r" will end up with a strong count of 1."]
        #[doc = r""]
        #[doc =
        r#" [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc"#]
        #[doc(cfg(all(feature = "rc",
        any(feature = "std", feature = "alloc"))))]
        impl<'de, T> Deserialize<'de> for Arc<T> where T: ?Sized,
            Box<T>: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Box::deserialize(deserializer).map(Into::into)
            }
        }
        impl<'de, T> Deserialize<'de> for Cell<T> where T: Deserialize<'de> +
            Copy {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                T::deserialize(deserializer).map(Cell::new)
            }
        }
        impl<'de, T: Deserialize<'de>> Deserialize<'de> for RefCell<T> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(RefCell::new)
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de, T: Deserialize<'de>> Deserialize<'de> for Mutex<T> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Mutex::new)
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de, T: Deserialize<'de>> Deserialize<'de> for RwLock<T> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(RwLock::new)
            }
        }
        impl<'de> Deserialize<'de> for Duration {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                enum Field { Secs, Nanos, }
                impl<'de> Deserialize<'de> for Field {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                        where D: Deserializer<'de> {
                        struct FieldVisitor;
                        impl<'de> Visitor<'de> for FieldVisitor {
                            type Value = Field;
                            fn expecting(&self, formatter: &mut fmt::Formatter)
                                -> fmt::Result {
                                formatter.write_str("`secs` or `nanos`")
                            }
                            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                                where E: Error {
                                match value {
                                    "secs" => Ok(Field::Secs),
                                    "nanos" => Ok(Field::Nanos),
                                    _ => Err(Error::unknown_field(value, FIELDS)),
                                }
                            }
                            fn visit_bytes<E>(self, value: &[u8])
                                -> Result<Self::Value, E> where E: Error {
                                match value {
                                    b"secs" => Ok(Field::Secs),
                                    b"nanos" => Ok(Field::Nanos),
                                    _ => {
                                        let value = private::string::from_utf8_lossy(value);
                                        Err(Error::unknown_field(&*value, FIELDS))
                                    }
                                }
                            }
                        }
                        deserializer.deserialize_identifier(FieldVisitor)
                    }
                }
                fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
                    where E: Error {
                    static NANOS_PER_SEC: u32 = 1_000_000_000;
                    match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
                        Some(_) => Ok(()),
                        None => Err(E::custom("overflow deserializing Duration")),
                    }
                }
                struct DurationVisitor;
                impl<'de> Visitor<'de> for DurationVisitor {
                    type Value = Duration;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("struct Duration")
                    }
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let secs: u64 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => { return Err(Error::invalid_length(0, &self)); }
                            };
                        let nanos: u32 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => { return Err(Error::invalid_length(1, &self)); }
                            };
                        match check_overflow(secs, nanos) {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        };
                        Ok(Duration::new(secs, nanos))
                    }
                    fn visit_map<A>(self, mut map: A)
                        -> Result<Self::Value, A::Error> where A: MapAccess<'de> {
                        let mut secs: Option<u64> = None;
                        let mut nanos: Option<u32> = None;
                        while let Some(key) =
                                match map.next_key() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            match key {
                                Field::Secs => {
                                    if secs.is_some() {
                                        return Err(<A::Error as Error>::duplicate_field("secs"));
                                    }
                                    secs =
                                        Some(match map.next_value() {
                                                Ok(val) => val,
                                                Err(err) => return Err(err),
                                            });
                                }
                                Field::Nanos => {
                                    if nanos.is_some() {
                                        return Err(<A::Error as Error>::duplicate_field("nanos"));
                                    }
                                    nanos =
                                        Some(match map.next_value() {
                                                Ok(val) => val,
                                                Err(err) => return Err(err),
                                            });
                                }
                            }
                        }
                        let secs =
                            match secs {
                                Some(secs) => secs,
                                None =>
                                    return Err(<A::Error as Error>::missing_field("secs")),
                            };
                        let nanos =
                            match nanos {
                                Some(nanos) => nanos,
                                None =>
                                    return Err(<A::Error as Error>::missing_field("nanos")),
                            };
                        match check_overflow(secs, nanos) {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        };
                        Ok(Duration::new(secs, nanos))
                    }
                }
                const FIELDS: &[&str] = &["secs", "nanos"];
                deserializer.deserialize_struct("Duration", FIELDS,
                    DurationVisitor)
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<'de> Deserialize<'de> for SystemTime {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                enum Field { Secs, Nanos, }
                impl<'de> Deserialize<'de> for Field {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                        where D: Deserializer<'de> {
                        struct FieldVisitor;
                        impl<'de> Visitor<'de> for FieldVisitor {
                            type Value = Field;
                            fn expecting(&self, formatter: &mut fmt::Formatter)
                                -> fmt::Result {
                                formatter.write_str("`secs_since_epoch` or `nanos_since_epoch`")
                            }
                            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                                where E: Error {
                                match value {
                                    "secs_since_epoch" => Ok(Field::Secs),
                                    "nanos_since_epoch" => Ok(Field::Nanos),
                                    _ => Err(Error::unknown_field(value, FIELDS)),
                                }
                            }
                            fn visit_bytes<E>(self, value: &[u8])
                                -> Result<Self::Value, E> where E: Error {
                                match value {
                                    b"secs_since_epoch" => Ok(Field::Secs),
                                    b"nanos_since_epoch" => Ok(Field::Nanos),
                                    _ => {
                                        let value = String::from_utf8_lossy(value);
                                        Err(Error::unknown_field(&value, FIELDS))
                                    }
                                }
                            }
                        }
                        deserializer.deserialize_identifier(FieldVisitor)
                    }
                }
                fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
                    where E: Error {
                    static NANOS_PER_SEC: u32 = 1_000_000_000;
                    match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
                        Some(_) => Ok(()),
                        None =>
                            Err(E::custom("overflow deserializing SystemTime epoch offset")),
                    }
                }
                struct DurationVisitor;
                impl<'de> Visitor<'de> for DurationVisitor {
                    type Value = Duration;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("struct SystemTime")
                    }
                    fn visit_seq<A>(self, mut seq: A)
                        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                        let secs: u64 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => { return Err(Error::invalid_length(0, &self)); }
                            };
                        let nanos: u32 =
                            match match seq.next_element() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                                Some(value) => value,
                                None => { return Err(Error::invalid_length(1, &self)); }
                            };
                        match check_overflow(secs, nanos) {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        };
                        Ok(Duration::new(secs, nanos))
                    }
                    fn visit_map<A>(self, mut map: A)
                        -> Result<Self::Value, A::Error> where A: MapAccess<'de> {
                        let mut secs: Option<u64> = None;
                        let mut nanos: Option<u32> = None;
                        while let Some(key) =
                                match map.next_key() {
                                    Ok(val) => val,
                                    Err(err) => return Err(err),
                                } {
                            match key {
                                Field::Secs => {
                                    if secs.is_some() {
                                        return Err(<A::Error as
                                                        Error>::duplicate_field("secs_since_epoch"));
                                    }
                                    secs =
                                        Some(match map.next_value() {
                                                Ok(val) => val,
                                                Err(err) => return Err(err),
                                            });
                                }
                                Field::Nanos => {
                                    if nanos.is_some() {
                                        return Err(<A::Error as
                                                        Error>::duplicate_field("nanos_since_epoch"));
                                    }
                                    nanos =
                                        Some(match map.next_value() {
                                                Ok(val) => val,
                                                Err(err) => return Err(err),
                                            });
                                }
                            }
                        }
                        let secs =
                            match secs {
                                Some(secs) => secs,
                                None =>
                                    return Err(<A::Error as
                                                    Error>::missing_field("secs_since_epoch")),
                            };
                        let nanos =
                            match nanos {
                                Some(nanos) => nanos,
                                None =>
                                    return Err(<A::Error as
                                                    Error>::missing_field("nanos_since_epoch")),
                            };
                        match check_overflow(secs, nanos) {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        };
                        Ok(Duration::new(secs, nanos))
                    }
                }
                const FIELDS: &[&str] =
                    &["secs_since_epoch", "nanos_since_epoch"];
                let duration =
                    match deserializer.deserialize_struct("SystemTime", FIELDS,
                            DurationVisitor) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                UNIX_EPOCH.checked_add(duration).ok_or_else(||
                        D::Error::custom("overflow deserializing SystemTime"))
            }
        }
        impl<'de, Idx> Deserialize<'de> for Range<Idx> where
            Idx: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                let (start, end) =
                    match deserializer.deserialize_struct("Range",
                            range::FIELDS,
                            range::RangeVisitor {
                                expecting: "struct Range",
                                phantom: PhantomData,
                            }) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                Ok(start..end)
            }
        }
        impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx> where
            Idx: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                let (start, end) =
                    match deserializer.deserialize_struct("RangeInclusive",
                            range::FIELDS,
                            range::RangeVisitor {
                                expecting: "struct RangeInclusive",
                                phantom: PhantomData,
                            }) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                Ok(RangeInclusive::new(start, end))
            }
        }
        mod range {
            use crate::lib::*;
            use crate::de::{
                Deserialize, Deserializer, Error, MapAccess, SeqAccess,
                Visitor,
            };
            use crate::private;
            pub const FIELDS: &[&str] = &["start", "end"];
            enum Field { Start, End, }
            impl<'de> Deserialize<'de> for Field {
                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de> {
                    struct FieldVisitor;
                    impl<'de> Visitor<'de> for FieldVisitor {
                        type Value = Field;
                        fn expecting(&self, formatter: &mut fmt::Formatter)
                            -> fmt::Result {
                            formatter.write_str("`start` or `end`")
                        }
                        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                            where E: Error {
                            match value {
                                "start" => Ok(Field::Start),
                                "end" => Ok(Field::End),
                                _ => Err(Error::unknown_field(value, FIELDS)),
                            }
                        }
                        fn visit_bytes<E>(self, value: &[u8])
                            -> Result<Self::Value, E> where E: Error {
                            match value {
                                b"start" => Ok(Field::Start),
                                b"end" => Ok(Field::End),
                                _ => {
                                    let value = private::string::from_utf8_lossy(value);
                                    Err(Error::unknown_field(&*value, FIELDS))
                                }
                            }
                        }
                    }
                    deserializer.deserialize_identifier(FieldVisitor)
                }
            }
            pub struct RangeVisitor<Idx> {
                pub expecting: &'static str,
                pub phantom: PhantomData<Idx>,
            }
            impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx> where
                Idx: Deserialize<'de> {
                type Value = (Idx, Idx);
                fn expecting(&self, formatter: &mut fmt::Formatter)
                    -> fmt::Result {
                    formatter.write_str(self.expecting)
                }
                fn visit_seq<A>(self, mut seq: A)
                    -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                    let start: Idx =
                        match match seq.next_element() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                            Some(value) => value,
                            None => { return Err(Error::invalid_length(0, &self)); }
                        };
                    let end: Idx =
                        match match seq.next_element() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                            Some(value) => value,
                            None => { return Err(Error::invalid_length(1, &self)); }
                        };
                    Ok((start, end))
                }
                fn visit_map<A>(self, mut map: A)
                    -> Result<Self::Value, A::Error> where A: MapAccess<'de> {
                    let mut start: Option<Idx> = None;
                    let mut end: Option<Idx> = None;
                    while let Some(key) =
                            match map.next_key() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                        match key {
                            Field::Start => {
                                if start.is_some() {
                                    return Err(<A::Error as Error>::duplicate_field("start"));
                                }
                                start =
                                    Some(match map.next_value() {
                                            Ok(val) => val,
                                            Err(err) => return Err(err),
                                        });
                            }
                            Field::End => {
                                if end.is_some() {
                                    return Err(<A::Error as Error>::duplicate_field("end"));
                                }
                                end =
                                    Some(match map.next_value() {
                                            Ok(val) => val,
                                            Err(err) => return Err(err),
                                        });
                            }
                        }
                    }
                    let start =
                        match start {
                            Some(start) => start,
                            None =>
                                return Err(<A::Error as Error>::missing_field("start")),
                        };
                    let end =
                        match end {
                            Some(end) => end,
                            None =>
                                return Err(<A::Error as Error>::missing_field("end")),
                        };
                    Ok((start, end))
                }
            }
        }
        impl<'de, Idx> Deserialize<'de> for RangeFrom<Idx> where
            Idx: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                let start =
                    match deserializer.deserialize_struct("RangeFrom",
                            range_from::FIELDS,
                            range_from::RangeFromVisitor {
                                expecting: "struct RangeFrom",
                                phantom: PhantomData,
                            }) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                Ok(start..)
            }
        }
        mod range_from {
            use crate::lib::*;
            use crate::de::{
                Deserialize, Deserializer, Error, MapAccess, SeqAccess,
                Visitor,
            };
            use crate::private;
            pub const FIELDS: &[&str] = &["start"];
            enum Field { Start, }
            impl<'de> Deserialize<'de> for Field {
                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de> {
                    struct FieldVisitor;
                    impl<'de> Visitor<'de> for FieldVisitor {
                        type Value = Field;
                        fn expecting(&self, formatter: &mut fmt::Formatter)
                            -> fmt::Result {
                            formatter.write_str("`start`")
                        }
                        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                            where E: Error {
                            match value {
                                "start" => Ok(Field::Start),
                                _ => Err(Error::unknown_field(value, FIELDS)),
                            }
                        }
                        fn visit_bytes<E>(self, value: &[u8])
                            -> Result<Self::Value, E> where E: Error {
                            match value {
                                b"start" => Ok(Field::Start),
                                _ => {
                                    let value = private::string::from_utf8_lossy(value);
                                    Err(Error::unknown_field(&*value, FIELDS))
                                }
                            }
                        }
                    }
                    deserializer.deserialize_identifier(FieldVisitor)
                }
            }
            pub struct RangeFromVisitor<Idx> {
                pub expecting: &'static str,
                pub phantom: PhantomData<Idx>,
            }
            impl<'de, Idx> Visitor<'de> for RangeFromVisitor<Idx> where
                Idx: Deserialize<'de> {
                type Value = Idx;
                fn expecting(&self, formatter: &mut fmt::Formatter)
                    -> fmt::Result {
                    formatter.write_str(self.expecting)
                }
                fn visit_seq<A>(self, mut seq: A)
                    -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                    let start: Idx =
                        match match seq.next_element() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                            Some(value) => value,
                            None => { return Err(Error::invalid_length(0, &self)); }
                        };
                    Ok(start)
                }
                fn visit_map<A>(self, mut map: A)
                    -> Result<Self::Value, A::Error> where A: MapAccess<'de> {
                    let mut start: Option<Idx> = None;
                    while let Some(key) =
                            match map.next_key() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                        match key {
                            Field::Start => {
                                if start.is_some() {
                                    return Err(<A::Error as Error>::duplicate_field("start"));
                                }
                                start =
                                    Some(match map.next_value() {
                                            Ok(val) => val,
                                            Err(err) => return Err(err),
                                        });
                            }
                        }
                    }
                    let start =
                        match start {
                            Some(start) => start,
                            None =>
                                return Err(<A::Error as Error>::missing_field("start")),
                        };
                    Ok(start)
                }
            }
        }
        impl<'de, Idx> Deserialize<'de> for RangeTo<Idx> where
            Idx: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                let end =
                    match deserializer.deserialize_struct("RangeTo",
                            range_to::FIELDS,
                            range_to::RangeToVisitor {
                                expecting: "struct RangeTo",
                                phantom: PhantomData,
                            }) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                Ok(..end)
            }
        }
        mod range_to {
            use crate::lib::*;
            use crate::de::{
                Deserialize, Deserializer, Error, MapAccess, SeqAccess,
                Visitor,
            };
            use crate::private;
            pub const FIELDS: &[&str] = &["end"];
            enum Field { End, }
            impl<'de> Deserialize<'de> for Field {
                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de> {
                    struct FieldVisitor;
                    impl<'de> Visitor<'de> for FieldVisitor {
                        type Value = Field;
                        fn expecting(&self, formatter: &mut fmt::Formatter)
                            -> fmt::Result {
                            formatter.write_str("`end`")
                        }
                        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                            where E: Error {
                            match value {
                                "end" => Ok(Field::End),
                                _ => Err(Error::unknown_field(value, FIELDS)),
                            }
                        }
                        fn visit_bytes<E>(self, value: &[u8])
                            -> Result<Self::Value, E> where E: Error {
                            match value {
                                b"end" => Ok(Field::End),
                                _ => {
                                    let value = private::string::from_utf8_lossy(value);
                                    Err(Error::unknown_field(&*value, FIELDS))
                                }
                            }
                        }
                    }
                    deserializer.deserialize_identifier(FieldVisitor)
                }
            }
            pub struct RangeToVisitor<Idx> {
                pub expecting: &'static str,
                pub phantom: PhantomData<Idx>,
            }
            impl<'de, Idx> Visitor<'de> for RangeToVisitor<Idx> where
                Idx: Deserialize<'de> {
                type Value = Idx;
                fn expecting(&self, formatter: &mut fmt::Formatter)
                    -> fmt::Result {
                    formatter.write_str(self.expecting)
                }
                fn visit_seq<A>(self, mut seq: A)
                    -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
                    let end: Idx =
                        match match seq.next_element() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                            Some(value) => value,
                            None => { return Err(Error::invalid_length(0, &self)); }
                        };
                    Ok(end)
                }
                fn visit_map<A>(self, mut map: A)
                    -> Result<Self::Value, A::Error> where A: MapAccess<'de> {
                    let mut end: Option<Idx> = None;
                    while let Some(key) =
                            match map.next_key() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                        match key {
                            Field::End => {
                                if end.is_some() {
                                    return Err(<A::Error as Error>::duplicate_field("end"));
                                }
                                end =
                                    Some(match map.next_value() {
                                            Ok(val) => val,
                                            Err(err) => return Err(err),
                                        });
                            }
                        }
                    }
                    let end =
                        match end {
                            Some(end) => end,
                            None =>
                                return Err(<A::Error as Error>::missing_field("end")),
                        };
                    Ok(end)
                }
            }
        }
        impl<'de, T> Deserialize<'de> for Bound<T> where T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                enum Field { Unbounded, Included, Excluded, }
                impl<'de> Deserialize<'de> for Field {
                    #[inline]
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                        where D: Deserializer<'de> {
                        struct FieldVisitor;
                        impl<'de> Visitor<'de> for FieldVisitor {
                            type Value = Field;
                            fn expecting(&self, formatter: &mut fmt::Formatter)
                                -> fmt::Result {
                                formatter.write_str("`Unbounded`, `Included` or `Excluded`")
                            }
                            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                                where E: Error {
                                match value {
                                    0 => Ok(Field::Unbounded),
                                    1 => Ok(Field::Included),
                                    2 => Ok(Field::Excluded),
                                    _ =>
                                        Err(Error::invalid_value(Unexpected::Unsigned(value),
                                                &self)),
                                }
                            }
                            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                                where E: Error {
                                match value {
                                    "Unbounded" => Ok(Field::Unbounded),
                                    "Included" => Ok(Field::Included),
                                    "Excluded" => Ok(Field::Excluded),
                                    _ => Err(Error::unknown_variant(value, VARIANTS)),
                                }
                            }
                            fn visit_bytes<E>(self, value: &[u8])
                                -> Result<Self::Value, E> where E: Error {
                                match value {
                                    b"Unbounded" => Ok(Field::Unbounded),
                                    b"Included" => Ok(Field::Included),
                                    b"Excluded" => Ok(Field::Excluded),
                                    _ =>
                                        match str::from_utf8(value) {
                                            Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
                                            Err(_) => {
                                                Err(Error::invalid_value(Unexpected::Bytes(value), &self))
                                            }
                                        },
                                }
                            }
                        }
                        deserializer.deserialize_identifier(FieldVisitor)
                    }
                }
                struct BoundVisitor<T>(PhantomData<Bound<T>>);
                impl<'de, T> Visitor<'de> for BoundVisitor<T> where
                    T: Deserialize<'de> {
                    type Value = Bound<T>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("enum Bound")
                    }
                    fn visit_enum<A>(self, data: A)
                        -> Result<Self::Value, A::Error> where A: EnumAccess<'de> {
                        match match data.variant() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                            (Field::Unbounded, v) =>
                                v.unit_variant().map(|()| Bound::Unbounded),
                            (Field::Included, v) =>
                                v.newtype_variant().map(Bound::Included),
                            (Field::Excluded, v) =>
                                v.newtype_variant().map(Bound::Excluded),
                        }
                    }
                }
                const VARIANTS: &[&str] =
                    &["Unbounded", "Included", "Excluded"];
                deserializer.deserialize_enum("Bound", VARIANTS,
                    BoundVisitor(PhantomData))
            }
        }
        #[doc(cfg(feature = "result"))]
        impl<'de, T, E> Deserialize<'de> for Result<T, E> where
            T: Deserialize<'de>, E: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                enum Field { Ok, Err, }
                impl<'de> Deserialize<'de> for Field {
                    #[inline]
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                        where D: Deserializer<'de> {
                        struct FieldVisitor;
                        impl<'de> Visitor<'de> for FieldVisitor {
                            type Value = Field;
                            fn expecting(&self, formatter: &mut fmt::Formatter)
                                -> fmt::Result {
                                formatter.write_str("`Ok` or `Err`")
                            }
                            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                                where E: Error {
                                match value {
                                    0 => Ok(Field::Ok),
                                    1 => Ok(Field::Err),
                                    _ =>
                                        Err(Error::invalid_value(Unexpected::Unsigned(value),
                                                &self)),
                                }
                            }
                            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                                where E: Error {
                                match value {
                                    "Ok" => Ok(Field::Ok),
                                    "Err" => Ok(Field::Err),
                                    _ => Err(Error::unknown_variant(value, VARIANTS)),
                                }
                            }
                            fn visit_bytes<E>(self, value: &[u8])
                                -> Result<Self::Value, E> where E: Error {
                                match value {
                                    b"Ok" => Ok(Field::Ok),
                                    b"Err" => Ok(Field::Err),
                                    _ =>
                                        match str::from_utf8(value) {
                                            Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
                                            Err(_) => {
                                                Err(Error::invalid_value(Unexpected::Bytes(value), &self))
                                            }
                                        },
                                }
                            }
                        }
                        deserializer.deserialize_identifier(FieldVisitor)
                    }
                }
                struct ResultVisitor<T, E>(PhantomData<Result<T, E>>);
                impl<'de, T, E> Visitor<'de> for ResultVisitor<T, E> where
                    T: Deserialize<'de>, E: Deserialize<'de> {
                    type Value = Result<T, E>;
                    fn expecting(&self, formatter: &mut fmt::Formatter)
                        -> fmt::Result {
                        formatter.write_str("enum Result")
                    }
                    fn visit_enum<A>(self, data: A)
                        -> Result<Self::Value, A::Error> where A: EnumAccess<'de> {
                        match match data.variant() {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            } {
                            (Field::Ok, v) => v.newtype_variant().map(Ok),
                            (Field::Err, v) => v.newtype_variant().map(Err),
                        }
                    }
                }
                const VARIANTS: &[&str] = &["Ok", "Err"];
                deserializer.deserialize_enum("Result", VARIANTS,
                    ResultVisitor(PhantomData))
            }
        }
        impl<'de, T> Deserialize<'de> for Wrapping<T> where
            T: Deserialize<'de> {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Wrapping)
            }
        }
        macro_rules! atomic_impl {
            ($($ty:ident $size:expr)*) =>
            {
                $(#[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
                #[cfg_attr(docsrs,
                doc(cfg(all(feature = "std", target_has_atomic = $size))))]
                impl<'de> Deserialize<'de> for $ty
                {
                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                    where D: Deserializer<'de>,
                    { Deserialize::deserialize(deserializer).map(Self::new) }
                })*
            };
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "8")))]
        impl<'de> Deserialize<'de> for AtomicBool {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "8")))]
        impl<'de> Deserialize<'de> for AtomicI8 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "16")))]
        impl<'de> Deserialize<'de> for AtomicI16 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "32")))]
        impl<'de> Deserialize<'de> for AtomicI32 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "ptr")))]
        impl<'de> Deserialize<'de> for AtomicIsize {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "8")))]
        impl<'de> Deserialize<'de> for AtomicU8 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "16")))]
        impl<'de> Deserialize<'de> for AtomicU16 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "32")))]
        impl<'de> Deserialize<'de> for AtomicU32 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "ptr")))]
        impl<'de> Deserialize<'de> for AtomicUsize {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "64")))]
        impl<'de> Deserialize<'de> for AtomicI64 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "64")))]
        impl<'de> Deserialize<'de> for AtomicU64 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
                D: Deserializer<'de> {
                Deserialize::deserialize(deserializer).map(Self::new)
            }
        }
        struct FromStrVisitor<T> {
            expecting: &'static str,
            ty: PhantomData<T>,
        }
        impl<T> FromStrVisitor<T> {
            fn new(expecting: &'static str) -> Self {
                FromStrVisitor { expecting, ty: PhantomData }
            }
        }
        impl<'de, T> Visitor<'de> for FromStrVisitor<T> where T: str::FromStr,
            T::Err: fmt::Display {
            type Value = T;
            fn expecting(&self, formatter: &mut fmt::Formatter)
                -> fmt::Result {
                formatter.write_str(self.expecting)
            }
            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E> where
                E: Error {
                s.parse().map_err(Error::custom)
            }
        }
    }
    pub use self::ignored_any::IgnoredAny;
    #[doc(no_inline)]
    pub use std::error::Error as StdError;
    macro_rules! declare_error_trait {
        (Error: Sized $(+ $($supertrait:ident)::+)*) =>
        {
            /// The `Error` trait allows `Deserialize` implementations to create descriptive
            /// error messages belonging to the `Deserializer` against which they are
            /// currently running.
            ///
            /// Every `Deserializer` declares an `Error` type that encompasses both
            /// general-purpose deserialization errors as well as errors specific to the
            /// particular deserialization format. For example the `Error` type of
            /// `serde_json` can represent errors like an invalid JSON escape sequence or an
            /// unterminated string literal, in addition to the error cases that are part of
            /// this trait.
            ///
            /// Most deserializers should only need to provide the `Error::custom` method
            /// and inherit the default behavior for the other methods.
            ///
            /// # Example implementation
            ///
            /// The [example data format] presented on the website shows an error
            /// type appropriate for a basic JSON data format.
            ///
            /// [example data format]: https://serde.rs/data-format.html
            #[cfg_attr(not(no_diagnostic_namespace),
            diagnostic::on_unimplemented(message =
            "the trait bound `{Self}: serde::de::Error` is not satisfied",))]
            pub trait Error: Sized $(+ $($supertrait)::+)*
            {
                /// Raised when there is general error when deserializing a type.
                ///
                /// The message should not be capitalized and should not end with a period.
                ///
                /// ```edition2021
                /// # use std::str::FromStr;
                /// #
                /// # struct IpAddr;
                /// #
                /// # impl FromStr for IpAddr {
                /// #     type Err = String;
                /// #
                /// #     fn from_str(_: &str) -> Result<Self, String> {
                /// #         unimplemented!()
                /// #     }
                /// # }
                /// #
                /// use serde::de::{self, Deserialize, Deserializer};
                ///
                /// impl<'de> Deserialize<'de> for IpAddr {
                ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                ///     where
                ///         D: Deserializer<'de>,
                ///     {
                ///         let s = String::deserialize(deserializer)?;
                ///         s.parse().map_err(de::Error::custom)
                ///     }
                /// }
                /// ```
                fn custom<T>(msg: T) -> Self where T: Display;
                /// Raised when a `Deserialize` receives a type different from what it was
                /// expecting.
                ///
                /// The `unexp` argument provides information about what type was received.
                /// This is the type that was present in the input file or other source data
                /// of the Deserializer.
                ///
                /// The `exp` argument provides information about what type was being
                /// expected. This is the type that is written in the program.
                ///
                /// For example if we try to deserialize a String out of a JSON file
                /// containing an integer, the unexpected type is the integer and the
                /// expected type is the string.
                #[cold] fn invalid_type(unexp: Unexpected, exp: &dyn Expected)
                -> Self
                {
                    Error::custom(format_args!("invalid type: {}, expected {}",
                    unexp, exp))
                }
                /// Raised when a `Deserialize` receives a value of the right type but that
                /// is wrong for some other reason.
                ///
                /// The `unexp` argument provides information about what value was received.
                /// This is the value that was present in the input file or other source
                /// data of the Deserializer.
                ///
                /// The `exp` argument provides information about what value was being
                /// expected. This is the type that is written in the program.
                ///
                /// For example if we try to deserialize a String out of some binary data
                /// that is not valid UTF-8, the unexpected value is the bytes and the
                /// expected value is a string.
                #[cold] fn
                invalid_value(unexp: Unexpected, exp: &dyn Expected) -> Self
                {
                    Error::custom(format_args!("invalid value: {}, expected {}",
                    unexp, exp))
                }
                /// Raised when deserializing a sequence or map and the input data contains
                /// too many or too few elements.
                ///
                /// The `len` argument is the number of elements encountered. The sequence
                /// or map may have expected more arguments or fewer arguments.
                ///
                /// The `exp` argument provides information about what data was being
                /// expected. For example `exp` might say that a tuple of size 6 was
                /// expected.
                #[cold] fn invalid_length(len: usize, exp: &dyn Expected) ->
                Self
                {
                    Error::custom(format_args!("invalid length {}, expected {}",
                    len, exp))
                }
                /// Raised when a `Deserialize` enum type received a variant with an
                /// unrecognized name.
                #[cold] fn
                unknown_variant(variant: &str, expected: &'static
                [&'static str]) -> Self
                {
                    if expected.is_empty()
                    {
                        Error::custom(format_args!("unknown variant `{}`, there are no variants",
                        variant))
                    } else
                    {
                        Error::custom(format_args!("unknown variant `{}`, expected {}",
                        variant, OneOf { names: expected }))
                    }
                }
                /// Raised when a `Deserialize` struct type received a field with an
                /// unrecognized name.
                #[cold] fn
                unknown_field(field: &str, expected: &'static [&'static str])
                -> Self
                {
                    if expected.is_empty()
                    {
                        Error::custom(format_args!("unknown field `{}`, there are no fields",
                        field))
                    } else
                    {
                        Error::custom(format_args!("unknown field `{}`, expected {}",
                        field, OneOf { names: expected }))
                    }
                }
                /// Raised when a `Deserialize` struct type expected to receive a required
                /// field with a particular name but that field was not present in the
                /// input.
                #[cold] fn missing_field(field: &'static str) -> Self
                { Error::custom(format_args!("missing field `{}`", field)) }
                /// Raised when a `Deserialize` struct type received more than one of the
                /// same field.
                #[cold] fn duplicate_field(field: &'static str) -> Self
                { Error::custom(format_args!("duplicate field `{}`", field)) }
            }
        }
    }
    /// The `Error` trait allows `Deserialize` implementations to create descriptive
    /// error messages belonging to the `Deserializer` against which they are
    /// currently running.
    ///
    /// Every `Deserializer` declares an `Error` type that encompasses both
    /// general-purpose deserialization errors as well as errors specific to the
    /// particular deserialization format. For example the `Error` type of
    /// `serde_json` can represent errors like an invalid JSON escape sequence or an
    /// unterminated string literal, in addition to the error cases that are part of
    /// this trait.
    ///
    /// Most deserializers should only need to provide the `Error::custom` method
    /// and inherit the default behavior for the other methods.
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website shows an error
    /// type appropriate for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::Error` is not satisfied",)]
    pub trait Error: Sized + StdError {
        /// Raised when there is general error when deserializing a type.
        ///
        /// The message should not be capitalized and should not end with a period.
        ///
        /// ```edition2021
        /// # use std::str::FromStr;
        /// #
        /// # struct IpAddr;
        /// #
        /// # impl FromStr for IpAddr {
        /// #     type Err = String;
        /// #
        /// #     fn from_str(_: &str) -> Result<Self, String> {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// use serde::de::{self, Deserialize, Deserializer};
        ///
        /// impl<'de> Deserialize<'de> for IpAddr {
        ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        ///     where
        ///         D: Deserializer<'de>,
        ///     {
        ///         let s = String::deserialize(deserializer)?;
        ///         s.parse().map_err(de::Error::custom)
        ///     }
        /// }
        /// ```
        fn custom<T>(msg: T)
        -> Self
        where
        T: Display;
        /// Raised when a `Deserialize` receives a type different from what it was
        /// expecting.
        ///
        /// The `unexp` argument provides information about what type was received.
        /// This is the type that was present in the input file or other source data
        /// of the Deserializer.
        ///
        /// The `exp` argument provides information about what type was being
        /// expected. This is the type that is written in the program.
        ///
        /// For example if we try to deserialize a String out of a JSON file
        /// containing an integer, the unexpected type is the integer and the
        /// expected type is the string.
        #[cold]
        fn invalid_type(unexp: Unexpected, exp: &dyn Expected) -> Self {
            Error::custom(format_args!("invalid type: {0}, expected {1}",
                    unexp, exp))
        }
        /// Raised when a `Deserialize` receives a value of the right type but that
        /// is wrong for some other reason.
        ///
        /// The `unexp` argument provides information about what value was received.
        /// This is the value that was present in the input file or other source
        /// data of the Deserializer.
        ///
        /// The `exp` argument provides information about what value was being
        /// expected. This is the type that is written in the program.
        ///
        /// For example if we try to deserialize a String out of some binary data
        /// that is not valid UTF-8, the unexpected value is the bytes and the
        /// expected value is a string.
        #[cold]
        fn invalid_value(unexp: Unexpected, exp: &dyn Expected) -> Self {
            Error::custom(format_args!("invalid value: {0}, expected {1}",
                    unexp, exp))
        }
        /// Raised when deserializing a sequence or map and the input data contains
        /// too many or too few elements.
        ///
        /// The `len` argument is the number of elements encountered. The sequence
        /// or map may have expected more arguments or fewer arguments.
        ///
        /// The `exp` argument provides information about what data was being
        /// expected. For example `exp` might say that a tuple of size 6 was
        /// expected.
        #[cold]
        fn invalid_length(len: usize, exp: &dyn Expected) -> Self {
            Error::custom(format_args!("invalid length {0}, expected {1}",
                    len, exp))
        }
        /// Raised when a `Deserialize` enum type received a variant with an
        /// unrecognized name.
        #[cold]
        fn unknown_variant(variant: &str, expected: &'static [&'static str])
            -> Self {
            if expected.is_empty() {
                Error::custom(format_args!("unknown variant `{0}`, there are no variants",
                        variant))
            } else {
                Error::custom(format_args!("unknown variant `{0}`, expected {1}",
                        variant, OneOf { names: expected }))
            }
        }
        /// Raised when a `Deserialize` struct type received a field with an
        /// unrecognized name.
        #[cold]
        fn unknown_field(field: &str, expected: &'static [&'static str])
            -> Self {
            if expected.is_empty() {
                Error::custom(format_args!("unknown field `{0}`, there are no fields",
                        field))
            } else {
                Error::custom(format_args!("unknown field `{0}`, expected {1}",
                        field, OneOf { names: expected }))
            }
        }
        /// Raised when a `Deserialize` struct type expected to receive a required
        /// field with a particular name but that field was not present in the
        /// input.
        #[cold]
        fn missing_field(field: &'static str) -> Self {
            Error::custom(format_args!("missing field `{0}`", field))
        }
        /// Raised when a `Deserialize` struct type received more than one of the
        /// same field.
        #[cold]
        fn duplicate_field(field: &'static str) -> Self {
            Error::custom(format_args!("duplicate field `{0}`", field))
        }
    }
    /// `Unexpected` represents an unexpected invocation of any one of the `Visitor`
    /// trait methods.
    ///
    /// This is used as an argument to the `invalid_type`, `invalid_value`, and
    /// `invalid_length` methods of the `Error` trait to build error messages.
    ///
    /// ```edition2021
    /// # use std::fmt;
    /// #
    /// # use serde::de::{self, Unexpected, Visitor};
    /// #
    /// # struct Example;
    /// #
    /// # impl<'de> Visitor<'de> for Example {
    /// #     type Value = ();
    /// #
    /// #     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    /// #         write!(formatter, "definitely not a boolean")
    /// #     }
    /// #
    /// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
    /// where
    ///     E: de::Error,
    /// {
    ///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))
    /// }
    /// # }
    /// ```
    pub enum Unexpected<'a> {

        /// The input contained a boolean value that was not expected.
        Bool(bool),

        /// The input contained an unsigned integer `u8`, `u16`, `u32` or `u64` that
        /// was not expected.
        Unsigned(u64),

        /// The input contained a signed integer `i8`, `i16`, `i32` or `i64` that
        /// was not expected.
        Signed(i64),

        /// The input contained a floating point `f32` or `f64` that was not
        /// expected.
        Float(f64),

        /// The input contained a `char` that was not expected.
        Char(char),

        /// The input contained a `&str` or `String` that was not expected.
        Str(&'a str),

        /// The input contained a `&[u8]` or `Vec<u8>` that was not expected.
        Bytes(&'a [u8]),

        /// The input contained a unit `()` that was not expected.
        Unit,

        /// The input contained an `Option<T>` that was not expected.
        Option,

        /// The input contained a newtype struct that was not expected.
        NewtypeStruct,

        /// The input contained a sequence that was not expected.
        Seq,

        /// The input contained a map that was not expected.
        Map,

        /// The input contained an enum that was not expected.
        Enum,

        /// The input contained a unit variant that was not expected.
        UnitVariant,

        /// The input contained a newtype variant that was not expected.
        NewtypeVariant,

        /// The input contained a tuple variant that was not expected.
        TupleVariant,

        /// The input contained a struct variant that was not expected.
        StructVariant,

        /// A message stating what uncategorized thing the input contained that was
        /// not expected.
        ///
        /// The message should be a noun or noun phrase, not capitalized and without
        /// a period. An example message is "unoriginal superhero".
        Other(&'a str),
    }
    #[automatically_derived]
    impl<'a> ::core::marker::Copy for Unexpected<'a> { }
    #[automatically_derived]
    impl<'a> ::core::clone::Clone for Unexpected<'a> {
        #[inline]
        fn clone(&self) -> Unexpected<'a> {
            let _: ::core::clone::AssertParamIsClone<bool>;
            let _: ::core::clone::AssertParamIsClone<u64>;
            let _: ::core::clone::AssertParamIsClone<i64>;
            let _: ::core::clone::AssertParamIsClone<f64>;
            let _: ::core::clone::AssertParamIsClone<char>;
            let _: ::core::clone::AssertParamIsClone<&'a str>;
            let _: ::core::clone::AssertParamIsClone<&'a [u8]>;
            let _: ::core::clone::AssertParamIsClone<&'a str>;
            *self
        }
    }
    #[automatically_derived]
    impl<'a> ::core::marker::StructuralPartialEq for Unexpected<'a> { }
    #[automatically_derived]
    impl<'a> ::core::cmp::PartialEq for Unexpected<'a> {
        #[inline]
        fn eq(&self, other: &Unexpected<'a>) -> bool {
            let __self_discr = ::core::intrinsics::discriminant_value(self);
            let __arg1_discr = ::core::intrinsics::discriminant_value(other);
            __self_discr == __arg1_discr &&
                match (self, other) {
                    (Unexpected::Bool(__self_0), Unexpected::Bool(__arg1_0)) =>
                        __self_0 == __arg1_0,
                    (Unexpected::Unsigned(__self_0),
                        Unexpected::Unsigned(__arg1_0)) => __self_0 == __arg1_0,
                    (Unexpected::Signed(__self_0), Unexpected::Signed(__arg1_0))
                        => __self_0 == __arg1_0,
                    (Unexpected::Float(__self_0), Unexpected::Float(__arg1_0))
                        => __self_0 == __arg1_0,
                    (Unexpected::Char(__self_0), Unexpected::Char(__arg1_0)) =>
                        __self_0 == __arg1_0,
                    (Unexpected::Str(__self_0), Unexpected::Str(__arg1_0)) =>
                        __self_0 == __arg1_0,
                    (Unexpected::Bytes(__self_0), Unexpected::Bytes(__arg1_0))
                        => __self_0 == __arg1_0,
                    (Unexpected::Other(__self_0), Unexpected::Other(__arg1_0))
                        => __self_0 == __arg1_0,
                    _ => true,
                }
        }
    }
    #[automatically_derived]
    impl<'a> ::core::fmt::Debug for Unexpected<'a> {
        #[inline]
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match self {
                Unexpected::Bool(__self_0) =>
                    ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Bool",
                        &__self_0),
                Unexpected::Unsigned(__self_0) =>
                    ::core::fmt::Formatter::debug_tuple_field1_finish(f,
                        "Unsigned", &__self_0),
                Unexpected::Signed(__self_0) =>
                    ::core::fmt::Formatter::debug_tuple_field1_finish(f,
                        "Signed", &__self_0),
                Unexpected::Float(__self_0) =>
                    ::core::fmt::Formatter::debug_tuple_field1_finish(f,
                        "Float", &__self_0),
                Unexpected::Char(__self_0) =>
                    ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Char",
                        &__self_0),
                Unexpected::Str(__self_0) =>
                    ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Str",
                        &__self_0),
                Unexpected::Bytes(__self_0) =>
                    ::core::fmt::Formatter::debug_tuple_field1_finish(f,
                        "Bytes", &__self_0),
                Unexpected::Unit =>
                    ::core::fmt::Formatter::write_str(f, "Unit"),
                Unexpected::Option =>
                    ::core::fmt::Formatter::write_str(f, "Option"),
                Unexpected::NewtypeStruct =>
                    ::core::fmt::Formatter::write_str(f, "NewtypeStruct"),
                Unexpected::Seq =>
                    ::core::fmt::Formatter::write_str(f, "Seq"),
                Unexpected::Map =>
                    ::core::fmt::Formatter::write_str(f, "Map"),
                Unexpected::Enum =>
                    ::core::fmt::Formatter::write_str(f, "Enum"),
                Unexpected::UnitVariant =>
                    ::core::fmt::Formatter::write_str(f, "UnitVariant"),
                Unexpected::NewtypeVariant =>
                    ::core::fmt::Formatter::write_str(f, "NewtypeVariant"),
                Unexpected::TupleVariant =>
                    ::core::fmt::Formatter::write_str(f, "TupleVariant"),
                Unexpected::StructVariant =>
                    ::core::fmt::Formatter::write_str(f, "StructVariant"),
                Unexpected::Other(__self_0) =>
                    ::core::fmt::Formatter::debug_tuple_field1_finish(f,
                        "Other", &__self_0),
            }
        }
    }
    impl<'a> fmt::Display for Unexpected<'a> {
        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            use self::Unexpected::*;
            match *self {
                Bool(b) =>
                    formatter.write_fmt(format_args!("boolean `{0}`", b)),
                Unsigned(i) =>
                    formatter.write_fmt(format_args!("integer `{0}`", i)),
                Signed(i) =>
                    formatter.write_fmt(format_args!("integer `{0}`", i)),
                Float(f) =>
                    formatter.write_fmt(format_args!("floating point `{0}`",
                            WithDecimalPoint(f))),
                Char(c) =>
                    formatter.write_fmt(format_args!("character `{0}`", c)),
                Str(s) =>
                    formatter.write_fmt(format_args!("string {0:?}", s)),
                Bytes(_) => formatter.write_str("byte array"),
                Unit => formatter.write_str("unit value"),
                Option => formatter.write_str("Option value"),
                NewtypeStruct => formatter.write_str("newtype struct"),
                Seq => formatter.write_str("sequence"),
                Map => formatter.write_str("map"),
                Enum => formatter.write_str("enum"),
                UnitVariant => formatter.write_str("unit variant"),
                NewtypeVariant => formatter.write_str("newtype variant"),
                TupleVariant => formatter.write_str("tuple variant"),
                StructVariant => formatter.write_str("struct variant"),
                Other(other) => formatter.write_str(other),
            }
        }
    }
    /// `Expected` represents an explanation of what data a `Visitor` was expecting
    /// to receive.
    ///
    /// This is used as an argument to the `invalid_type`, `invalid_value`, and
    /// `invalid_length` methods of the `Error` trait to build error messages. The
    /// message should be a noun or noun phrase that completes the sentence "This
    /// Visitor expects to receive ...", for example the message could be "an
    /// integer between 0 and 64". The message should not be capitalized and should
    /// not end with a period.
    ///
    /// Within the context of a `Visitor` implementation, the `Visitor` itself
    /// (`&self`) is an implementation of this trait.
    ///
    /// ```edition2021
    /// # use serde::de::{self, Unexpected, Visitor};
    /// # use std::fmt;
    /// #
    /// # struct Example;
    /// #
    /// # impl<'de> Visitor<'de> for Example {
    /// #     type Value = ();
    /// #
    /// #     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    /// #         write!(formatter, "definitely not a boolean")
    /// #     }
    /// #
    /// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
    /// where
    ///     E: de::Error,
    /// {
    ///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))
    /// }
    /// # }
    /// ```
    ///
    /// Outside of a `Visitor`, `&"..."` can be used.
    ///
    /// ```edition2021
    /// # use serde::de::{self, Unexpected};
    /// #
    /// # fn example<E>() -> Result<(), E>
    /// # where
    /// #     E: de::Error,
    /// # {
    /// #     let v = true;
    /// return Err(de::Error::invalid_type(
    ///     Unexpected::Bool(v),
    ///     &"a negative integer",
    /// ));
    /// # }
    /// ```
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::Expected` is not satisfied",)]
    pub trait Expected {
        /// Format an explanation of what data was being expected. Same signature as
        /// the `Display` and `Debug` traits.
        fn fmt(&self, formatter: &mut fmt::Formatter)
        -> fmt::Result;
    }
    impl<'de, T> Expected for T where T: Visitor<'de> {
        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            self.expecting(formatter)
        }
    }
    impl Expected for &str {
        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            formatter.write_str(self)
        }
    }
    impl Display for dyn Expected + '_ {
        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            Expected::fmt(self, formatter)
        }
    }
    /// A **data structure** that can be deserialized from any data format supported
    /// by Serde.
    ///
    /// Serde provides `Deserialize` implementations for many Rust primitive and
    /// standard library types. The complete list is [here][crate::de]. All of these
    /// can be deserialized using Serde out of the box.
    ///
    /// Additionally, Serde provides a procedural macro called `serde_derive` to
    /// automatically generate `Deserialize` implementations for structs and enums
    /// in your program. See the [derive section of the manual][derive] for how to
    /// use this.
    ///
    /// In rare cases it may be necessary to implement `Deserialize` manually for
    /// some type in your program. See the [Implementing
    /// `Deserialize`][impl-deserialize] section of the manual for more about this.
    ///
    /// Third-party crates may provide `Deserialize` implementations for types that
    /// they expose. For example the `linked-hash-map` crate provides a
    /// `LinkedHashMap<K, V>` type that is deserializable by Serde because the crate
    /// provides an implementation of `Deserialize` for it.
    ///
    /// [derive]: https://serde.rs/derive.html
    /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the lifetime of data that may be
    /// borrowed by `Self` when deserialized. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::Deserialize<'de>` is not satisfied", note
    =
    "for local types consider adding `#[derive(serde::Deserialize)]` to your `{Self}` type",
    note =
    "for types from other crates check whether the crate offers a `serde` feature flag",)]
    pub trait Deserialize<'de>: Sized {
        /// Deserialize this value from the given Serde deserializer.
        ///
        /// See the [Implementing `Deserialize`][impl-deserialize] section of the
        /// manual for more information about how to implement this method.
        ///
        /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
        fn deserialize<D>(deserializer: D)
        -> Result<Self, D::Error>
        where
        D: Deserializer<'de>;
        /// Deserializes a value into `self` from the given Deserializer.
        ///
        /// The purpose of this method is to allow the deserializer to reuse
        /// resources and avoid copies. As such, if this method returns an error,
        /// `self` will be in an indeterminate state where some parts of the struct
        /// have been overwritten. Although whatever state that is will be
        /// memory-safe.
        ///
        /// This is generally useful when repeatedly deserializing values that
        /// are processed one at a time, where the value of `self` doesn't matter
        /// when the next deserialization occurs.
        ///
        /// If you manually implement this, your recursive deserializations should
        /// use `deserialize_in_place`.
        ///
        /// This method is stable and an official public API, but hidden from the
        /// documentation because it is almost never what newbies are looking for.
        /// Showing it in rustdoc would cause it to be featured more prominently
        /// than it deserves.
        #[doc(hidden)]
        fn deserialize_in_place<D>(deserializer: D, place: &mut Self)
            -> Result<(), D::Error> where D: Deserializer<'de> {
            *place =
                match Deserialize::deserialize(deserializer) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
            Ok(())
        }
    }
    /// A data structure that can be deserialized without borrowing any data from
    /// the deserializer.
    ///
    /// This is primarily useful for trait bounds on functions. For example a
    /// `from_str` function may be able to deserialize a data structure that borrows
    /// from the input string, but a `from_reader` function may only deserialize
    /// owned data.
    ///
    /// ```edition2021
    /// # use serde::de::{Deserialize, DeserializeOwned};
    /// # use std::io::{Read, Result};
    /// #
    /// # trait Ignore {
    /// fn from_str<'a, T>(s: &'a str) -> Result<T>
    /// where
    ///     T: Deserialize<'a>;
    ///
    /// fn from_reader<R, T>(rdr: R) -> Result<T>
    /// where
    ///     R: Read,
    ///     T: DeserializeOwned;
    /// # }
    /// ```
    ///
    /// # Lifetime
    ///
    /// The relationship between `Deserialize` and `DeserializeOwned` in trait
    /// bounds is explained in more detail on the page [Understanding deserializer
    /// lifetimes].
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::DeserializeOwned` is not satisfied",)]
    pub trait DeserializeOwned: for<'de> Deserialize<'de> { }
    impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
    /// `DeserializeSeed` is the stateful form of the `Deserialize` trait. If you
    /// ever find yourself looking for a way to pass data into a `Deserialize` impl,
    /// this trait is the way to do it.
    ///
    /// As one example of stateful deserialization consider deserializing a JSON
    /// array into an existing buffer. Using the `Deserialize` trait we could
    /// deserialize a JSON array into a `Vec<T>` but it would be a freshly allocated
    /// `Vec<T>`; there is no way for `Deserialize` to reuse a previously allocated
    /// buffer. Using `DeserializeSeed` instead makes this possible as in the
    /// example code below.
    ///
    /// The canonical API for stateless deserialization looks like this:
    ///
    /// ```edition2021
    /// # use serde::Deserialize;
    /// #
    /// # enum Error {}
    /// #
    /// fn func<'de, T: Deserialize<'de>>() -> Result<T, Error>
    /// # {
    /// #     unimplemented!()
    /// # }
    /// ```
    ///
    /// Adjusting an API like this to support stateful deserialization is a matter
    /// of accepting a seed as input:
    ///
    /// ```edition2021
    /// # use serde::de::DeserializeSeed;
    /// #
    /// # enum Error {}
    /// #
    /// fn func_seed<'de, T: DeserializeSeed<'de>>(seed: T) -> Result<T::Value, Error>
    /// # {
    /// #     let _ = seed;
    /// #     unimplemented!()
    /// # }
    /// ```
    ///
    /// In practice the majority of deserialization is stateless. An API expecting a
    /// seed can be appeased by passing `std::marker::PhantomData` as a seed in the
    /// case of stateless deserialization.
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the lifetime of data that may be
    /// borrowed by `Self::Value` when deserialized. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    ///
    /// # Example
    ///
    /// Suppose we have JSON that looks like `[[1, 2], [3, 4, 5], [6]]` and we need
    /// to deserialize it into a flat representation like `vec![1, 2, 3, 4, 5, 6]`.
    /// Allocating a brand new `Vec<T>` for each subarray would be slow. Instead we
    /// would like to allocate a single `Vec<T>` and then deserialize each subarray
    /// into it. This requires stateful deserialization using the `DeserializeSeed`
    /// trait.
    ///
    /// ```edition2021
    /// use serde::de::{Deserialize, DeserializeSeed, Deserializer, SeqAccess, Visitor};
    /// use std::fmt;
    /// use std::marker::PhantomData;
    ///
    /// // A DeserializeSeed implementation that uses stateful deserialization to
    /// // append array elements onto the end of an existing vector. The preexisting
    /// // state ("seed") in this case is the Vec<T>. The `deserialize` method of
    /// // `ExtendVec` will be traversing the inner arrays of the JSON input and
    /// // appending each integer into the existing Vec.
    /// struct ExtendVec<'a, T: 'a>(&'a mut Vec<T>);
    ///
    /// impl<'de, 'a, T> DeserializeSeed<'de> for ExtendVec<'a, T>
    /// where
    ///     T: Deserialize<'de>,
    /// {
    ///     // The return type of the `deserialize` method. This implementation
    ///     // appends onto an existing vector but does not create any new data
    ///     // structure, so the return type is ().
    ///     type Value = ();
    ///
    ///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    ///     where
    ///         D: Deserializer<'de>,
    ///     {
    ///         // Visitor implementation that will walk an inner array of the JSON
    ///         // input.
    ///         struct ExtendVecVisitor<'a, T: 'a>(&'a mut Vec<T>);
    ///
    ///         impl<'de, 'a, T> Visitor<'de> for ExtendVecVisitor<'a, T>
    ///         where
    ///             T: Deserialize<'de>,
    ///         {
    ///             type Value = ();
    ///
    ///             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    ///                 write!(formatter, "an array of integers")
    ///             }
    ///
    ///             fn visit_seq<A>(self, mut seq: A) -> Result<(), A::Error>
    ///             where
    ///                 A: SeqAccess<'de>,
    ///             {
    ///                 // Decrease the number of reallocations if there are many elements
    ///                 if let Some(size_hint) = seq.size_hint() {
    ///                     self.0.reserve(size_hint);
    ///                 }
    ///
    ///                 // Visit each element in the inner array and push it onto
    ///                 // the existing vector.
    ///                 while let Some(elem) = seq.next_element()? {
    ///                     self.0.push(elem);
    ///                 }
    ///                 Ok(())
    ///             }
    ///         }
    ///
    ///         deserializer.deserialize_seq(ExtendVecVisitor(self.0))
    ///     }
    /// }
    ///
    /// // Visitor implementation that will walk the outer array of the JSON input.
    /// struct FlattenedVecVisitor<T>(PhantomData<T>);
    ///
    /// impl<'de, T> Visitor<'de> for FlattenedVecVisitor<T>
    /// where
    ///     T: Deserialize<'de>,
    /// {
    ///     // This Visitor constructs a single Vec<T> to hold the flattened
    ///     // contents of the inner arrays.
    ///     type Value = Vec<T>;
    ///
    ///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    ///         write!(formatter, "an array of arrays")
    ///     }
    ///
    ///     fn visit_seq<A>(self, mut seq: A) -> Result<Vec<T>, A::Error>
    ///     where
    ///         A: SeqAccess<'de>,
    ///     {
    ///         // Create a single Vec to hold the flattened contents.
    ///         let mut vec = Vec::new();
    ///
    ///         // Each iteration through this loop is one inner array.
    ///         while let Some(()) = seq.next_element_seed(ExtendVec(&mut vec))? {
    ///             // Nothing to do; inner array has been appended into `vec`.
    ///         }
    ///
    ///         // Return the finished vec.
    ///         Ok(vec)
    ///     }
    /// }
    ///
    /// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
    /// # where
    /// #     D: Deserializer<'de>,
    /// # {
    /// let visitor = FlattenedVecVisitor(PhantomData);
    /// let flattened: Vec<u64> = deserializer.deserialize_seq(visitor)?;
    /// #     Ok(())
    /// # }
    /// ```
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::DeserializeSeed<'de>` is not satisfied",)]
    pub trait DeserializeSeed<'de>: Sized {
        /// The type produced by using this seed.
        type Value;
        /// Equivalent to the more common `Deserialize::deserialize` method, except
        /// with some initial piece of data (the seed) passed in.
        fn deserialize<D>(self, deserializer: D)
        -> Result<Self::Value, D::Error>
        where
        D: Deserializer<'de>;
    }
    impl<'de, T> DeserializeSeed<'de> for PhantomData<T> where
        T: Deserialize<'de> {
        type Value = T;
        #[inline]
        fn deserialize<D>(self, deserializer: D) -> Result<T, D::Error> where
            D: Deserializer<'de> {
            T::deserialize(deserializer)
        }
    }
    /// A **data format** that can deserialize any data structure supported by
    /// Serde.
    ///
    /// The role of this trait is to define the deserialization half of the [Serde
    /// data model], which is a way to categorize every Rust data type into one of
    /// 29 possible types. Each method of the `Deserializer` trait corresponds to one
    /// of the types of the data model.
    ///
    /// Implementations of `Deserialize` map themselves into this data model by
    /// passing to the `Deserializer` a `Visitor` implementation that can receive
    /// these various types.
    ///
    /// The types that make up the Serde data model are:
    ///
    ///  - **14 primitive types**
    ///    - bool
    ///    - i8, i16, i32, i64, i128
    ///    - u8, u16, u32, u64, u128
    ///    - f32, f64
    ///    - char
    ///  - **string**
    ///    - UTF-8 bytes with a length and no null terminator.
    ///    - When serializing, all strings are handled equally. When deserializing,
    ///      there are three flavors of strings: transient, owned, and borrowed.
    ///  - **byte array** - \[u8\]
    ///    - Similar to strings, during deserialization byte arrays can be
    ///      transient, owned, or borrowed.
    ///  - **option**
    ///    - Either none or some value.
    ///  - **unit**
    ///    - The type of `()` in Rust. It represents an anonymous value containing
    ///      no data.
    ///  - **unit_struct**
    ///    - For example `struct Unit` or `PhantomData<T>`. It represents a named
    ///      value containing no data.
    ///  - **unit_variant**
    ///    - For example the `E::A` and `E::B` in `enum E { A, B }`.
    ///  - **newtype_struct**
    ///    - For example `struct Millimeters(u8)`.
    ///  - **newtype_variant**
    ///    - For example the `E::N` in `enum E { N(u8) }`.
    ///  - **seq**
    ///    - A variably sized heterogeneous sequence of values, for example `Vec<T>`
    ///      or `HashSet<T>`. When serializing, the length may or may not be known
    ///      before iterating through all the data. When deserializing, the length
    ///      is determined by looking at the serialized data.
    ///  - **tuple**
    ///    - A statically sized heterogeneous sequence of values for which the
    ///      length will be known at deserialization time without looking at the
    ///      serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or
    ///      `[u64; 10]`.
    ///  - **tuple_struct**
    ///    - A named tuple, for example `struct Rgb(u8, u8, u8)`.
    ///  - **tuple_variant**
    ///    - For example the `E::T` in `enum E { T(u8, u8) }`.
    ///  - **map**
    ///    - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
    ///  - **struct**
    ///    - A heterogeneous key-value pairing in which the keys are strings and
    ///      will be known at deserialization time without looking at the serialized
    ///      data, for example `struct S { r: u8, g: u8, b: u8 }`.
    ///  - **struct_variant**
    ///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
    ///
    /// The `Deserializer` trait supports two entry point styles which enables
    /// different kinds of deserialization.
    ///
    /// 1. The `deserialize_any` method. Self-describing data formats like JSON are
    ///    able to look at the serialized data and tell what it represents. For
    ///    example the JSON deserializer may see an opening curly brace (`{`) and
    ///    know that it is seeing a map. If the data format supports
    ///    `Deserializer::deserialize_any`, it will drive the Visitor using whatever
    ///    type it sees in the input. JSON uses this approach when deserializing
    ///    `serde_json::Value` which is an enum that can represent any JSON
    ///    document. Without knowing what is in a JSON document, we can deserialize
    ///    it to `serde_json::Value` by going through
    ///    `Deserializer::deserialize_any`.
    ///
    /// 2. The various `deserialize_*` methods. Non-self-describing formats like
    ///    Postcard need to be told what is in the input in order to deserialize it.
    ///    The `deserialize_*` methods are hints to the deserializer for how to
    ///    interpret the next piece of input. Non-self-describing formats are not
    ///    able to deserialize something like `serde_json::Value` which relies on
    ///    `Deserializer::deserialize_any`.
    ///
    /// When implementing `Deserialize`, you should avoid relying on
    /// `Deserializer::deserialize_any` unless you need to be told by the
    /// Deserializer what type is in the input. Know that relying on
    /// `Deserializer::deserialize_any` means your data type will be able to
    /// deserialize from self-describing formats only, ruling out Postcard and many
    /// others.
    ///
    /// [Serde data model]: https://serde.rs/data-model.html
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the lifetime of data that may be
    /// borrowed from the input when deserializing. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website contains example code for
    /// a basic JSON `Deserializer`.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::Deserializer<'de>` is not satisfied",)]
    pub trait Deserializer<'de>: Sized {
        /// The error type that can be returned if some error occurs during
        /// deserialization.
        type Error: Error;
        /// Require the `Deserializer` to figure out how to drive the visitor based
        /// on what data type is in the input.
        ///
        /// When implementing `Deserialize`, you should avoid relying on
        /// `Deserializer::deserialize_any` unless you need to be told by the
        /// Deserializer what type is in the input. Know that relying on
        /// `Deserializer::deserialize_any` means your data type will be able to
        /// deserialize from self-describing formats only, ruling out Postcard and
        /// many others.
        fn deserialize_any<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a `bool` value.
        fn deserialize_bool<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting an `i8` value.
        fn deserialize_i8<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting an `i16` value.
        fn deserialize_i16<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting an `i32` value.
        fn deserialize_i32<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting an `i64` value.
        fn deserialize_i64<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting an `i128` value.
        ///
        /// The default behavior unconditionally returns an error.
        fn deserialize_i128<V>(self, visitor: V)
            -> Result<V::Value, Self::Error> where V: Visitor<'de> {
            let _ = visitor;
            Err(Error::custom("i128 is not supported"))
        }
        /// Hint that the `Deserialize` type is expecting a `u8` value.
        fn deserialize_u8<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a `u16` value.
        fn deserialize_u16<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a `u32` value.
        fn deserialize_u32<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a `u64` value.
        fn deserialize_u64<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting an `u128` value.
        ///
        /// The default behavior unconditionally returns an error.
        fn deserialize_u128<V>(self, visitor: V)
            -> Result<V::Value, Self::Error> where V: Visitor<'de> {
            let _ = visitor;
            Err(Error::custom("u128 is not supported"))
        }
        /// Hint that the `Deserialize` type is expecting a `f32` value.
        fn deserialize_f32<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a `f64` value.
        fn deserialize_f64<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a `char` value.
        fn deserialize_char<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a string value and does
        /// not benefit from taking ownership of buffered data owned by the
        /// `Deserializer`.
        ///
        /// If the `Visitor` would benefit from taking ownership of `String` data,
        /// indicate this to the `Deserializer` by using `deserialize_string`
        /// instead.
        fn deserialize_str<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a string value and would
        /// benefit from taking ownership of buffered data owned by the
        /// `Deserializer`.
        ///
        /// If the `Visitor` would not benefit from taking ownership of `String`
        /// data, indicate that to the `Deserializer` by using `deserialize_str`
        /// instead.
        fn deserialize_string<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a byte array and does not
        /// benefit from taking ownership of buffered data owned by the
        /// `Deserializer`.
        ///
        /// If the `Visitor` would benefit from taking ownership of `Vec<u8>` data,
        /// indicate this to the `Deserializer` by using `deserialize_byte_buf`
        /// instead.
        fn deserialize_bytes<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a byte array and would
        /// benefit from taking ownership of buffered data owned by the
        /// `Deserializer`.
        ///
        /// If the `Visitor` would not benefit from taking ownership of `Vec<u8>`
        /// data, indicate that to the `Deserializer` by using `deserialize_bytes`
        /// instead.
        fn deserialize_byte_buf<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting an optional value.
        ///
        /// This allows deserializers that encode an optional value as a nullable
        /// value to convert the null value into `None` and a regular value into
        /// `Some(value)`.
        fn deserialize_option<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a unit value.
        fn deserialize_unit<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a unit struct with a
        /// particular name.
        fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a newtype struct with a
        /// particular name.
        fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a sequence of values.
        fn deserialize_seq<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a sequence of values and
        /// knows how many values there are without looking at the serialized data.
        fn deserialize_tuple<V>(self, len: usize, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a tuple struct with a
        /// particular name and number of fields.
        fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize,
        visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a map of key-value pairs.
        fn deserialize_map<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting a struct with a particular
        /// name and fields.
        fn deserialize_struct<V>(self, name: &'static str,
        fields: &'static [&'static str], visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting an enum value with a
        /// particular name and possible variants.
        fn deserialize_enum<V>(self, name: &'static str,
        variants: &'static [&'static str], visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type is expecting the name of a struct
        /// field or the discriminant of an enum variant.
        fn deserialize_identifier<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Hint that the `Deserialize` type needs to deserialize a value whose type
        /// doesn't matter because it is ignored.
        ///
        /// Deserializers for non-self-describing formats may not support this mode.
        fn deserialize_ignored_any<V>(self, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Determine whether `Deserialize` implementations should expect to
        /// deserialize their human-readable form.
        ///
        /// Some types have a human-readable form that may be somewhat expensive to
        /// construct, as well as a binary form that is compact and efficient.
        /// Generally text-based formats like JSON and YAML will prefer to use the
        /// human-readable one and binary formats like Postcard will prefer the
        /// compact one.
        ///
        /// ```edition2021
        /// # use std::ops::Add;
        /// # use std::str::FromStr;
        /// #
        /// # struct Timestamp;
        /// #
        /// # impl Timestamp {
        /// #     const EPOCH: Timestamp = Timestamp;
        /// # }
        /// #
        /// # impl FromStr for Timestamp {
        /// #     type Err = String;
        /// #     fn from_str(_: &str) -> Result<Self, Self::Err> {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// # struct Duration;
        /// #
        /// # impl Duration {
        /// #     fn seconds(_: u64) -> Self { unimplemented!() }
        /// # }
        /// #
        /// # impl Add<Duration> for Timestamp {
        /// #     type Output = Timestamp;
        /// #     fn add(self, _: Duration) -> Self::Output {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// use serde::de::{self, Deserialize, Deserializer};
        ///
        /// impl<'de> Deserialize<'de> for Timestamp {
        ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        ///     where
        ///         D: Deserializer<'de>,
        ///     {
        ///         if deserializer.is_human_readable() {
        ///             // Deserialize from a human-readable string like "2015-05-15T17:01:00Z".
        ///             let s = String::deserialize(deserializer)?;
        ///             Timestamp::from_str(&s).map_err(de::Error::custom)
        ///         } else {
        ///             // Deserialize from a compact binary representation, seconds since
        ///             // the Unix epoch.
        ///             let n = u64::deserialize(deserializer)?;
        ///             Ok(Timestamp::EPOCH + Duration::seconds(n))
        ///         }
        ///     }
        /// }
        /// ```
        ///
        /// The default implementation of this method returns `true`. Data formats
        /// may override this to `false` to request a compact form for types that
        /// support one. Note that modifying this method to change a format from
        /// human-readable to compact or vice versa should be regarded as a breaking
        /// change, as a value serialized in human-readable mode is not required to
        /// deserialize from the same data in compact mode.
        #[inline]
        fn is_human_readable(&self) -> bool { true }
        #[doc(hidden)]
        fn __deserialize_content_v1<V>(self, visitor: V)
            -> Result<V::Value, Self::Error> where
            V: Visitor<'de, Value = crate::private::Content<'de>> {
            self.deserialize_any(visitor)
        }
    }
    /// This trait represents a visitor that walks through a deserializer.
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the requirement for lifetime of data
    /// that may be borrowed by `Self::Value`. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    ///
    /// # Example
    ///
    /// ```edition2021
    /// # use serde::de::{self, Unexpected, Visitor};
    /// # use std::fmt;
    /// #
    /// /// A visitor that deserializes a long string - a string containing at least
    /// /// some minimum number of bytes.
    /// struct LongString {
    ///     min: usize,
    /// }
    ///
    /// impl<'de> Visitor<'de> for LongString {
    ///     type Value = String;
    ///
    ///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    ///         write!(formatter, "a string containing at least {} bytes", self.min)
    ///     }
    ///
    ///     fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
    ///     where
    ///         E: de::Error,
    ///     {
    ///         if s.len() >= self.min {
    ///             Ok(s.to_owned())
    ///         } else {
    ///             Err(de::Error::invalid_value(Unexpected::Str(s), &self))
    ///         }
    ///     }
    /// }
    /// ```
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::Visitor<'de>` is not satisfied",)]
    pub trait Visitor<'de>: Sized {
        /// The value produced by this visitor.
        type Value;
        /// Format a message stating what data this Visitor expects to receive.
        ///
        /// This is used in error messages. The message should complete the sentence
        /// "This Visitor expects to receive ...", for example the message could be
        /// "an integer between 0 and 64". The message should not be capitalized and
        /// should not end with a period.
        ///
        /// ```edition2021
        /// # use std::fmt;
        /// #
        /// # struct S {
        /// #     max: usize,
        /// # }
        /// #
        /// # impl<'de> serde::de::Visitor<'de> for S {
        /// #     type Value = ();
        /// #
        /// fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        ///     write!(formatter, "an integer between 0 and {}", self.max)
        /// }
        /// # }
        /// ```
        fn expecting(&self, formatter: &mut fmt::Formatter)
        -> fmt::Result;
        /// The input contains a boolean.
        ///
        /// The default implementation fails with a type error.
        fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E> where
            E: Error {
            Err(Error::invalid_type(Unexpected::Bool(v), &self))
        }
        /// The input contains an `i8`.
        ///
        /// The default implementation forwards to [`visit_i64`].
        ///
        /// [`visit_i64`]: #method.visit_i64
        fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where E: Error {
            self.visit_i64(v as i64)
        }
        /// The input contains an `i16`.
        ///
        /// The default implementation forwards to [`visit_i64`].
        ///
        /// [`visit_i64`]: #method.visit_i64
        fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E> where
            E: Error {
            self.visit_i64(v as i64)
        }
        /// The input contains an `i32`.
        ///
        /// The default implementation forwards to [`visit_i64`].
        ///
        /// [`visit_i64`]: #method.visit_i64
        fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E> where
            E: Error {
            self.visit_i64(v as i64)
        }
        /// The input contains an `i64`.
        ///
        /// The default implementation fails with a type error.
        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> where
            E: Error {
            Err(Error::invalid_type(Unexpected::Signed(v), &self))
        }
        /// The input contains a `i128`.
        ///
        /// The default implementation fails with a type error.
        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E> where
            E: Error {
            let mut buf = [0u8; 58];
            let mut writer = crate::format::Buf::new(&mut buf);
            fmt::Write::write_fmt(&mut writer,
                    format_args!("integer `{0}` as i128", v)).unwrap();
            Err(Error::invalid_type(Unexpected::Other(writer.as_str()),
                    &self))
        }
        /// The input contains a `u8`.
        ///
        /// The default implementation forwards to [`visit_u64`].
        ///
        /// [`visit_u64`]: #method.visit_u64
        fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where E: Error {
            self.visit_u64(v as u64)
        }
        /// The input contains a `u16`.
        ///
        /// The default implementation forwards to [`visit_u64`].
        ///
        /// [`visit_u64`]: #method.visit_u64
        fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E> where
            E: Error {
            self.visit_u64(v as u64)
        }
        /// The input contains a `u32`.
        ///
        /// The default implementation forwards to [`visit_u64`].
        ///
        /// [`visit_u64`]: #method.visit_u64
        fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E> where
            E: Error {
            self.visit_u64(v as u64)
        }
        /// The input contains a `u64`.
        ///
        /// The default implementation fails with a type error.
        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> where
            E: Error {
            Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
        }
        /// The input contains a `u128`.
        ///
        /// The default implementation fails with a type error.
        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E> where
            E: Error {
            let mut buf = [0u8; 57];
            let mut writer = crate::format::Buf::new(&mut buf);
            fmt::Write::write_fmt(&mut writer,
                    format_args!("integer `{0}` as u128", v)).unwrap();
            Err(Error::invalid_type(Unexpected::Other(writer.as_str()),
                    &self))
        }
        /// The input contains an `f32`.
        ///
        /// The default implementation forwards to [`visit_f64`].
        ///
        /// [`visit_f64`]: #method.visit_f64
        fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E> where
            E: Error {
            self.visit_f64(v as f64)
        }
        /// The input contains an `f64`.
        ///
        /// The default implementation fails with a type error.
        fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E> where
            E: Error {
            Err(Error::invalid_type(Unexpected::Float(v), &self))
        }
        /// The input contains a `char`.
        ///
        /// The default implementation forwards to [`visit_str`] as a one-character
        /// string.
        ///
        /// [`visit_str`]: #method.visit_str
        #[inline]
        fn visit_char<E>(self, v: char) -> Result<Self::Value, E> where
            E: Error {
            self.visit_str(v.encode_utf8(&mut [0u8; 4]))
        }
        /// The input contains a string. The lifetime of the string is ephemeral and
        /// it may be destroyed after this method returns.
        ///
        /// This method allows the `Deserializer` to avoid a copy by retaining
        /// ownership of any buffered data. `Deserialize` implementations that do
        /// not benefit from taking ownership of `String` data should indicate that
        /// to the deserializer by using `Deserializer::deserialize_str` rather than
        /// `Deserializer::deserialize_string`.
        ///
        /// It is never correct to implement `visit_string` without implementing
        /// `visit_str`. Implement neither, both, or just `visit_str`.
        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where
            E: Error {
            Err(Error::invalid_type(Unexpected::Str(v), &self))
        }
        /// The input contains a string that lives at least as long as the
        /// `Deserializer`.
        ///
        /// This enables zero-copy deserialization of strings in some formats. For
        /// example JSON input containing the JSON string `"borrowed"` can be
        /// deserialized with zero copying into a `&'a str` as long as the input
        /// data outlives `'a`.
        ///
        /// The default implementation forwards to `visit_str`.
        #[inline]
        fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
            where E: Error {
            self.visit_str(v)
        }
        /// The input contains a string and ownership of the string is being given
        /// to the `Visitor`.
        ///
        /// This method allows the `Visitor` to avoid a copy by taking ownership of
        /// a string created by the `Deserializer`. `Deserialize` implementations
        /// that benefit from taking ownership of `String` data should indicate that
        /// to the deserializer by using `Deserializer::deserialize_string` rather
        /// than `Deserializer::deserialize_str`, although not every deserializer
        /// will honor such a request.
        ///
        /// It is never correct to implement `visit_string` without implementing
        /// `visit_str`. Implement neither, both, or just `visit_str`.
        ///
        /// The default implementation forwards to `visit_str` and then drops the
        /// `String`.
        #[inline]
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        fn visit_string<E>(self, v: String) -> Result<Self::Value, E> where
            E: Error {
            self.visit_str(&v)
        }
        /// The input contains a byte array. The lifetime of the byte array is
        /// ephemeral and it may be destroyed after this method returns.
        ///
        /// This method allows the `Deserializer` to avoid a copy by retaining
        /// ownership of any buffered data. `Deserialize` implementations that do
        /// not benefit from taking ownership of `Vec<u8>` data should indicate that
        /// to the deserializer by using `Deserializer::deserialize_bytes` rather
        /// than `Deserializer::deserialize_byte_buf`.
        ///
        /// It is never correct to implement `visit_byte_buf` without implementing
        /// `visit_bytes`. Implement neither, both, or just `visit_bytes`.
        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where
            E: Error {
            Err(Error::invalid_type(Unexpected::Bytes(v), &self))
        }
        /// The input contains a byte array that lives at least as long as the
        /// `Deserializer`.
        ///
        /// This enables zero-copy deserialization of bytes in some formats. For
        /// example Postcard data containing bytes can be deserialized with zero
        /// copying into a `&'a [u8]` as long as the input data outlives `'a`.
        ///
        /// The default implementation forwards to `visit_bytes`.
        #[inline]
        fn visit_borrowed_bytes<E>(self, v: &'de [u8])
            -> Result<Self::Value, E> where E: Error {
            self.visit_bytes(v)
        }
        /// The input contains a byte array and ownership of the byte array is being
        /// given to the `Visitor`.
        ///
        /// This method allows the `Visitor` to avoid a copy by taking ownership of
        /// a byte buffer created by the `Deserializer`. `Deserialize`
        /// implementations that benefit from taking ownership of `Vec<u8>` data
        /// should indicate that to the deserializer by using
        /// `Deserializer::deserialize_byte_buf` rather than
        /// `Deserializer::deserialize_bytes`, although not every deserializer will
        /// honor such a request.
        ///
        /// It is never correct to implement `visit_byte_buf` without implementing
        /// `visit_bytes`. Implement neither, both, or just `visit_bytes`.
        ///
        /// The default implementation forwards to `visit_bytes` and then drops the
        /// `Vec<u8>`.
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> where
            E: Error {
            self.visit_bytes(&v)
        }
        /// The input contains an optional that is absent.
        ///
        /// The default implementation fails with a type error.
        fn visit_none<E>(self) -> Result<Self::Value, E> where E: Error {
            Err(Error::invalid_type(Unexpected::Option, &self))
        }
        /// The input contains an optional that is present.
        ///
        /// The default implementation fails with a type error.
        fn visit_some<D>(self, deserializer: D)
            -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
            let _ = deserializer;
            Err(Error::invalid_type(Unexpected::Option, &self))
        }
        /// The input contains a unit `()`.
        ///
        /// The default implementation fails with a type error.
        fn visit_unit<E>(self) -> Result<Self::Value, E> where E: Error {
            Err(Error::invalid_type(Unexpected::Unit, &self))
        }
        /// The input contains a newtype struct.
        ///
        /// The content of the newtype struct may be read from the given
        /// `Deserializer`.
        ///
        /// The default implementation fails with a type error.
        fn visit_newtype_struct<D>(self, deserializer: D)
            -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
            let _ = deserializer;
            Err(Error::invalid_type(Unexpected::NewtypeStruct, &self))
        }
        /// The input contains a sequence of elements.
        ///
        /// The default implementation fails with a type error.
        fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> where
            A: SeqAccess<'de> {
            let _ = seq;
            Err(Error::invalid_type(Unexpected::Seq, &self))
        }
        /// The input contains a key-value map.
        ///
        /// The default implementation fails with a type error.
        fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error> where
            A: MapAccess<'de> {
            let _ = map;
            Err(Error::invalid_type(Unexpected::Map, &self))
        }
        /// The input contains an enum.
        ///
        /// The default implementation fails with a type error.
        fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error> where
            A: EnumAccess<'de> {
            let _ = data;
            Err(Error::invalid_type(Unexpected::Enum, &self))
        }
        #[doc(hidden)]
        fn __private_visit_untagged_option<D>(self, _: D)
            -> Result<Self::Value, ()> where D: Deserializer<'de> {
            Err(())
        }
    }
    /// Provides a `Visitor` access to each element of a sequence in the input.
    ///
    /// This is a trait that a `Deserializer` passes to a `Visitor` implementation,
    /// which deserializes each item in a sequence.
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the lifetime of data that may be
    /// borrowed by deserialized sequence elements. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `SeqAccess` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::SeqAccess<'de>` is not satisfied",)]
    pub trait SeqAccess<'de> {
        /// The error type that can be returned if some error occurs during
        /// deserialization.
        type Error: Error;
        /// This returns `Ok(Some(value))` for the next value in the sequence, or
        /// `Ok(None)` if there are no more remaining items.
        ///
        /// `Deserialize` implementations should typically use
        /// `SeqAccess::next_element` instead.
        fn next_element_seed<T>(&mut self, seed: T)
        -> Result<Option<T::Value>, Self::Error>
        where
        T: DeserializeSeed<'de>;
        /// This returns `Ok(Some(value))` for the next value in the sequence, or
        /// `Ok(None)` if there are no more remaining items.
        ///
        /// This method exists as a convenience for `Deserialize` implementations.
        /// `SeqAccess` implementations should not override the default behavior.
        #[inline]
        fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error> where
            T: Deserialize<'de> {
            self.next_element_seed(PhantomData)
        }
        /// Returns the number of elements remaining in the sequence, if known.
        #[inline]
        fn size_hint(&self) -> Option<usize> { None }
    }
    impl<'de, A> SeqAccess<'de> for &mut A where A: ?Sized + SeqAccess<'de> {
        type Error = A::Error;
        #[inline]
        fn next_element_seed<T>(&mut self, seed: T)
            -> Result<Option<T::Value>, Self::Error> where
            T: DeserializeSeed<'de> {
            (**self).next_element_seed(seed)
        }
        #[inline]
        fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error> where
            T: Deserialize<'de> {
            (**self).next_element()
        }
        #[inline]
        fn size_hint(&self) -> Option<usize> { (**self).size_hint() }
    }
    /// Provides a `Visitor` access to each entry of a map in the input.
    ///
    /// This is a trait that a `Deserializer` passes to a `Visitor` implementation.
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the lifetime of data that may be
    /// borrowed by deserialized map entries. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `MapAccess` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::MapAccess<'de>` is not satisfied",)]
    pub trait MapAccess<'de> {
        /// The error type that can be returned if some error occurs during
        /// deserialization.
        type Error: Error;
        /// This returns `Ok(Some(key))` for the next key in the map, or `Ok(None)`
        /// if there are no more remaining entries.
        ///
        /// `Deserialize` implementations should typically use
        /// `MapAccess::next_key` or `MapAccess::next_entry` instead.
        fn next_key_seed<K>(&mut self, seed: K)
        -> Result<Option<K::Value>, Self::Error>
        where
        K: DeserializeSeed<'de>;
        /// This returns a `Ok(value)` for the next value in the map.
        ///
        /// `Deserialize` implementations should typically use
        /// `MapAccess::next_value` instead.
        ///
        /// # Panics
        ///
        /// Calling `next_value_seed` before `next_key_seed` is incorrect and is
        /// allowed to panic or return bogus results.
        fn next_value_seed<V>(&mut self, seed: V)
        -> Result<V::Value, Self::Error>
        where
        V: DeserializeSeed<'de>;
        /// This returns `Ok(Some((key, value)))` for the next (key-value) pair in
        /// the map, or `Ok(None)` if there are no more remaining items.
        ///
        /// `MapAccess` implementations should override the default behavior if a
        /// more efficient implementation is possible.
        ///
        /// `Deserialize` implementations should typically use
        /// `MapAccess::next_entry` instead.
        #[inline]
        fn next_entry_seed<K, V>(&mut self, kseed: K, vseed: V)
            -> Result<Option<(K::Value, V::Value)>, Self::Error> where
            K: DeserializeSeed<'de>, V: DeserializeSeed<'de> {
            match match self.next_key_seed(kseed) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                } {
                Some(key) => {
                    let value =
                        match self.next_value_seed(vseed) {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        };
                    Ok(Some((key, value)))
                }
                None => Ok(None),
            }
        }
        /// This returns `Ok(Some(key))` for the next key in the map, or `Ok(None)`
        /// if there are no more remaining entries.
        ///
        /// This method exists as a convenience for `Deserialize` implementations.
        /// `MapAccess` implementations should not override the default behavior.
        #[inline]
        fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error> where
            K: Deserialize<'de> {
            self.next_key_seed(PhantomData)
        }
        /// This returns a `Ok(value)` for the next value in the map.
        ///
        /// This method exists as a convenience for `Deserialize` implementations.
        /// `MapAccess` implementations should not override the default behavior.
        ///
        /// # Panics
        ///
        /// Calling `next_value` before `next_key` is incorrect and is allowed to
        /// panic or return bogus results.
        #[inline]
        fn next_value<V>(&mut self) -> Result<V, Self::Error> where
            V: Deserialize<'de> {
            self.next_value_seed(PhantomData)
        }
        /// This returns `Ok(Some((key, value)))` for the next (key-value) pair in
        /// the map, or `Ok(None)` if there are no more remaining items.
        ///
        /// This method exists as a convenience for `Deserialize` implementations.
        /// `MapAccess` implementations should not override the default behavior.
        #[inline]
        fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
            where K: Deserialize<'de>, V: Deserialize<'de> {
            self.next_entry_seed(PhantomData, PhantomData)
        }
        /// Returns the number of entries remaining in the map, if known.
        #[inline]
        fn size_hint(&self) -> Option<usize> { None }
    }
    impl<'de, A> MapAccess<'de> for &mut A where A: ?Sized + MapAccess<'de> {
        type Error = A::Error;
        #[inline]
        fn next_key_seed<K>(&mut self, seed: K)
            -> Result<Option<K::Value>, Self::Error> where
            K: DeserializeSeed<'de> {
            (**self).next_key_seed(seed)
        }
        #[inline]
        fn next_value_seed<V>(&mut self, seed: V)
            -> Result<V::Value, Self::Error> where V: DeserializeSeed<'de> {
            (**self).next_value_seed(seed)
        }
        #[inline]
        fn next_entry_seed<K, V>(&mut self, kseed: K, vseed: V)
            -> Result<Option<(K::Value, V::Value)>, Self::Error> where
            K: DeserializeSeed<'de>, V: DeserializeSeed<'de> {
            (**self).next_entry_seed(kseed, vseed)
        }
        #[inline]
        fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
            where K: Deserialize<'de>, V: Deserialize<'de> {
            (**self).next_entry()
        }
        #[inline]
        fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error> where
            K: Deserialize<'de> {
            (**self).next_key()
        }
        #[inline]
        fn next_value<V>(&mut self) -> Result<V, Self::Error> where
            V: Deserialize<'de> {
            (**self).next_value()
        }
        #[inline]
        fn size_hint(&self) -> Option<usize> { (**self).size_hint() }
    }
    /// Provides a `Visitor` access to the data of an enum in the input.
    ///
    /// `EnumAccess` is created by the `Deserializer` and passed to the
    /// `Visitor` in order to identify which variant of an enum to deserialize.
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the lifetime of data that may be
    /// borrowed by the deserialized enum variant. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `EnumAccess` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::EnumAccess<'de>` is not satisfied",)]
    pub trait EnumAccess<'de>: Sized {
        /// The error type that can be returned if some error occurs during
        /// deserialization.
        type Error: Error;
        /// The `Visitor` that will be used to deserialize the content of the enum
        /// variant.
        type Variant: VariantAccess<'de, Error = Self::Error>;
        /// `variant` is called to identify which variant to deserialize.
        ///
        /// `Deserialize` implementations should typically use `EnumAccess::variant`
        /// instead.
        fn variant_seed<V>(self, seed: V)
        -> Result<(V::Value, Self::Variant), Self::Error>
        where
        V: DeserializeSeed<'de>;
        /// `variant` is called to identify which variant to deserialize.
        ///
        /// This method exists as a convenience for `Deserialize` implementations.
        /// `EnumAccess` implementations should not override the default behavior.
        #[inline]
        fn variant<V>(self) -> Result<(V, Self::Variant), Self::Error> where
            V: Deserialize<'de> {
            self.variant_seed(PhantomData)
        }
    }
    /// `VariantAccess` is a visitor that is created by the `Deserializer` and
    /// passed to the `Deserialize` to deserialize the content of a particular enum
    /// variant.
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the lifetime of data that may be
    /// borrowed by the deserialized enum variant. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `VariantAccess` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::VariantAccess<'de>` is not satisfied",)]
    pub trait VariantAccess<'de>: Sized {
        /// The error type that can be returned if some error occurs during
        /// deserialization. Must match the error type of our `EnumAccess`.
        type Error: Error;
        /// Called when deserializing a variant with no values.
        ///
        /// If the data contains a different type of variant, the following
        /// `invalid_type` error should be constructed:
        ///
        /// ```edition2021
        /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
        /// #
        /// # struct X;
        /// #
        /// # impl<'de> VariantAccess<'de> for X {
        /// #     type Error = value::Error;
        /// #
        /// fn unit_variant(self) -> Result<(), Self::Error> {
        ///     // What the data actually contained; suppose it is a tuple variant.
        ///     let unexp = Unexpected::TupleVariant;
        ///     Err(de::Error::invalid_type(unexp, &"unit variant"))
        /// }
        /// #
        /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
        /// #     where
        /// #         T: DeserializeSeed<'de>,
        /// #     { unimplemented!() }
        /// #
        /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
        /// #     where
        /// #         V: Visitor<'de>,
        /// #     { unimplemented!() }
        /// #
        /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
        /// #     where
        /// #         V: Visitor<'de>,
        /// #     { unimplemented!() }
        /// # }
        /// ```
        fn unit_variant(self)
        -> Result<(), Self::Error>;
        /// Called when deserializing a variant with a single value.
        ///
        /// `Deserialize` implementations should typically use
        /// `VariantAccess::newtype_variant` instead.
        ///
        /// If the data contains a different type of variant, the following
        /// `invalid_type` error should be constructed:
        ///
        /// ```edition2021
        /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
        /// #
        /// # struct X;
        /// #
        /// # impl<'de> VariantAccess<'de> for X {
        /// #     type Error = value::Error;
        /// #
        /// #     fn unit_variant(self) -> Result<(), Self::Error> {
        /// #         unimplemented!()
        /// #     }
        /// #
        /// fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
        /// where
        ///     T: DeserializeSeed<'de>,
        /// {
        ///     // What the data actually contained; suppose it is a unit variant.
        ///     let unexp = Unexpected::UnitVariant;
        ///     Err(de::Error::invalid_type(unexp, &"newtype variant"))
        /// }
        /// #
        /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
        /// #     where
        /// #         V: Visitor<'de>,
        /// #     { unimplemented!() }
        /// #
        /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
        /// #     where
        /// #         V: Visitor<'de>,
        /// #     { unimplemented!() }
        /// # }
        /// ```
        fn newtype_variant_seed<T>(self, seed: T)
        -> Result<T::Value, Self::Error>
        where
        T: DeserializeSeed<'de>;
        /// Called when deserializing a variant with a single value.
        ///
        /// This method exists as a convenience for `Deserialize` implementations.
        /// `VariantAccess` implementations should not override the default
        /// behavior.
        #[inline]
        fn newtype_variant<T>(self) -> Result<T, Self::Error> where
            T: Deserialize<'de> {
            self.newtype_variant_seed(PhantomData)
        }
        /// Called when deserializing a tuple-like variant.
        ///
        /// The `len` is the number of fields expected in the tuple variant.
        ///
        /// If the data contains a different type of variant, the following
        /// `invalid_type` error should be constructed:
        ///
        /// ```edition2021
        /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
        /// #
        /// # struct X;
        /// #
        /// # impl<'de> VariantAccess<'de> for X {
        /// #     type Error = value::Error;
        /// #
        /// #     fn unit_variant(self) -> Result<(), Self::Error> {
        /// #         unimplemented!()
        /// #     }
        /// #
        /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
        /// #     where
        /// #         T: DeserializeSeed<'de>,
        /// #     { unimplemented!() }
        /// #
        /// fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
        /// where
        ///     V: Visitor<'de>,
        /// {
        ///     // What the data actually contained; suppose it is a unit variant.
        ///     let unexp = Unexpected::UnitVariant;
        ///     Err(de::Error::invalid_type(unexp, &"tuple variant"))
        /// }
        /// #
        /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
        /// #     where
        /// #         V: Visitor<'de>,
        /// #     { unimplemented!() }
        /// # }
        /// ```
        fn tuple_variant<V>(self, len: usize, visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
        /// Called when deserializing a struct-like variant.
        ///
        /// The `fields` are the names of the fields of the struct variant.
        ///
        /// If the data contains a different type of variant, the following
        /// `invalid_type` error should be constructed:
        ///
        /// ```edition2021
        /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
        /// #
        /// # struct X;
        /// #
        /// # impl<'de> VariantAccess<'de> for X {
        /// #     type Error = value::Error;
        /// #
        /// #     fn unit_variant(self) -> Result<(), Self::Error> {
        /// #         unimplemented!()
        /// #     }
        /// #
        /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
        /// #     where
        /// #         T: DeserializeSeed<'de>,
        /// #     { unimplemented!() }
        /// #
        /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
        /// #     where
        /// #         V: Visitor<'de>,
        /// #     { unimplemented!() }
        /// #
        /// fn struct_variant<V>(
        ///     self,
        ///     _fields: &'static [&'static str],
        ///     _visitor: V,
        /// ) -> Result<V::Value, Self::Error>
        /// where
        ///     V: Visitor<'de>,
        /// {
        ///     // What the data actually contained; suppose it is a unit variant.
        ///     let unexp = Unexpected::UnitVariant;
        ///     Err(de::Error::invalid_type(unexp, &"struct variant"))
        /// }
        /// # }
        /// ```
        fn struct_variant<V>(self, fields: &'static [&'static str],
        visitor: V)
        -> Result<V::Value, Self::Error>
        where
        V: Visitor<'de>;
    }
    /// Converts an existing value into a `Deserializer` from which other values can
    /// be deserialized.
    ///
    /// # Lifetime
    ///
    /// The `'de` lifetime of this trait is the lifetime of data that may be
    /// borrowed from the resulting `Deserializer`. See the page [Understanding
    /// deserializer lifetimes] for a more detailed explanation of these lifetimes.
    ///
    /// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
    ///
    /// # Example
    ///
    /// ```edition2021
    /// use serde::de::{value, Deserialize, IntoDeserializer};
    /// use serde_derive::Deserialize;
    /// use std::str::FromStr;
    ///
    /// #[derive(Deserialize)]
    /// enum Setting {
    ///     On,
    ///     Off,
    /// }
    ///
    /// impl FromStr for Setting {
    ///     type Err = value::Error;
    ///
    ///     fn from_str(s: &str) -> Result<Self, Self::Err> {
    ///         Self::deserialize(s.into_deserializer())
    ///     }
    /// }
    /// ```
    pub trait IntoDeserializer<'de, E: Error = value::Error> {
        /// The type of the deserializer being converted into.
        type Deserializer: Deserializer<'de, Error = E>;
        /// Convert this value into a deserializer.
        fn into_deserializer(self)
        -> Self::Deserializer;
    }
    /// Used in error messages.
    ///
    /// - expected `a`
    /// - expected `a` or `b`
    /// - expected one of `a`, `b`, `c`
    ///
    /// The slice of names must not be empty.
    struct OneOf {
        names: &'static [&'static str],
    }
    impl Display for OneOf {
        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            match self.names.len() {
                0 => ::core::panicking::panic("explicit panic"),
                1 =>
                    formatter.write_fmt(format_args!("`{0}`", self.names[0])),
                2 =>
                    formatter.write_fmt(format_args!("`{0}` or `{1}`",
                            self.names[0], self.names[1])),
                _ => {
                    match formatter.write_str("one of ") {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                    for (i, alt) in self.names.iter().enumerate() {
                        if i > 0 {
                            match formatter.write_str(", ") {
                                Ok(val) => val,
                                Err(err) => return Err(err),
                            };
                        }
                        match formatter.write_fmt(format_args!("`{0}`", alt)) {
                            Ok(val) => val,
                            Err(err) => return Err(err),
                        };
                    }
                    Ok(())
                }
            }
        }
    }
    struct WithDecimalPoint(f64);
    impl Display for WithDecimalPoint {
        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            struct LookForDecimalPoint<'f, 'a> {
                formatter: &'f mut fmt::Formatter<'a>,
                has_decimal_point: bool,
            }
            impl<'f, 'a> fmt::Write for LookForDecimalPoint<'f, 'a> {
                fn write_str(&mut self, fragment: &str) -> fmt::Result {
                    self.has_decimal_point |= fragment.contains('.');
                    self.formatter.write_str(fragment)
                }
                fn write_char(&mut self, ch: char) -> fmt::Result {
                    self.has_decimal_point |= ch == '.';
                    self.formatter.write_char(ch)
                }
            }
            if self.0.is_finite() {
                let mut writer =
                    LookForDecimalPoint { formatter, has_decimal_point: false };
                match writer.write_fmt(format_args!("{0}", self.0)) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                if !writer.has_decimal_point {
                    match formatter.write_str(".0") {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
            } else {
                match formatter.write_fmt(format_args!("{0}", self.0)) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
            }
            Ok(())
        }
    }
}
pub mod ser {
    //! Generic data structure serialization framework.
    //!
    //! The two most important traits in this module are [`Serialize`] and
    //! [`Serializer`].
    //!
    //!  - **A type that implements `Serialize` is a data structure** that can be
    //!    serialized to any data format supported by Serde, and conversely
    //!  - **A type that implements `Serializer` is a data format** that can
    //!    serialize any data structure supported by Serde.
    //!
    //! # The Serialize trait
    //!
    //! Serde provides [`Serialize`] implementations for many Rust primitive and
    //! standard library types. The complete list is below. All of these can be
    //! serialized using Serde out of the box.
    //!
    //! Additionally, Serde provides a procedural macro called [`serde_derive`] to
    //! automatically generate [`Serialize`] implementations for structs and enums
    //! in your program. See the [derive section of the manual] for how to use this.
    //!
    //! In rare cases it may be necessary to implement [`Serialize`] manually for
    //! some type in your program. See the [Implementing `Serialize`] section of the
    //! manual for more about this.
    //!
    //! Third-party crates may provide [`Serialize`] implementations for types that
    //! they expose. For example the [`linked-hash-map`] crate provides a
    //! [`LinkedHashMap<K, V>`] type that is serializable by Serde because the crate
    //! provides an implementation of [`Serialize`] for it.
    //!
    //! # The Serializer trait
    //!
    //! [`Serializer`] implementations are provided by third-party crates, for
    //! example [`serde_json`], [`serde_yaml`] and [`postcard`].
    //!
    //! A partial list of well-maintained formats is given on the [Serde
    //! website][data formats].
    //!
    //! # Implementations of Serialize provided by Serde
    //!
    //!  - **Primitive types**:
    //!    - bool
    //!    - i8, i16, i32, i64, i128, isize
    //!    - u8, u16, u32, u64, u128, usize
    //!    - f32, f64
    //!    - char
    //!    - str
    //!    - &T and &mut T
    //!  - **Compound types**:
    //!    - \[T\]
    //!    - \[T; 0\] through \[T; 32\]
    //!    - tuples up to size 16
    //!  - **Common standard library types**:
    //!    - String
    //!    - Option\<T\>
    //!    - Result\<T, E\>
    //!    - PhantomData\<T\>
    //!  - **Wrapper types**:
    //!    - Box\<T\>
    //!    - Cow\<'a, T\>
    //!    - Cell\<T\>
    //!    - RefCell\<T\>
    //!    - Mutex\<T\>
    //!    - RwLock\<T\>
    //!    - Rc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
    //!    - Arc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
    //!  - **Collection types**:
    //!    - BTreeMap\<K, V\>
    //!    - BTreeSet\<T\>
    //!    - BinaryHeap\<T\>
    //!    - HashMap\<K, V, H\>
    //!    - HashSet\<T, H\>
    //!    - LinkedList\<T\>
    //!    - VecDeque\<T\>
    //!    - Vec\<T\>
    //!  - **FFI types**:
    //!    - CStr
    //!    - CString
    //!    - OsStr
    //!    - OsString
    //!  - **Miscellaneous standard library types**:
    //!    - Duration
    //!    - SystemTime
    //!    - Path
    //!    - PathBuf
    //!    - Range\<T\>
    //!    - RangeInclusive\<T\>
    //!    - Bound\<T\>
    //!    - num::NonZero*
    //!    - `!` *(unstable)*
    //!  - **Net types**:
    //!    - IpAddr
    //!    - Ipv4Addr
    //!    - Ipv6Addr
    //!    - SocketAddr
    //!    - SocketAddrV4
    //!    - SocketAddrV6
    //!
    //! [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
    //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
    //! [`Serialize`]: crate::Serialize
    //! [`Serializer`]: crate::Serializer
    //! [`postcard`]: https://github.com/jamesmunns/postcard
    //! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
    //! [`serde_derive`]: https://crates.io/crates/serde_derive
    //! [`serde_json`]: https://github.com/serde-rs/json
    //! [`serde_yaml`]: https://github.com/dtolnay/serde-yaml
    //! [derive section of the manual]: https://serde.rs/derive.html
    //! [data formats]: https://serde.rs/#data-formats
    use crate::lib::*;
    mod fmt {
        use crate::lib::*;
        use crate::ser::{Error, Impossible, Serialize, Serializer};
        impl Error for fmt::Error {
            fn custom<T: Display>(_msg: T) -> Self { fmt::Error }
        }
        macro_rules! fmt_primitives {
            ($($f:ident: $t:ty,)*) =>
            {
                $(fn $f(self, v: $t) -> fmt::Result
                { Display::fmt(&v, self) })*
            };
        }
        /// ```edition2021
        /// use serde::ser::Serialize;
        /// use serde_derive::Serialize;
        /// use std::fmt::{self, Display};
        ///
        /// #[derive(Serialize)]
        /// #[serde(rename_all = "kebab-case")]
        /// pub enum MessageType {
        ///     StartRequest,
        ///     EndRequest,
        /// }
        ///
        /// impl Display for MessageType {
        ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        ///         self.serialize(f)
        ///     }
        /// }
        /// ```
        impl<'a> Serializer for &mut fmt::Formatter<'a> {
            type Ok = ();
            type Error = fmt::Error;
            type SerializeSeq = Impossible<(), fmt::Error>;
            type SerializeTuple = Impossible<(), fmt::Error>;
            type SerializeTupleStruct = Impossible<(), fmt::Error>;
            type SerializeTupleVariant = Impossible<(), fmt::Error>;
            type SerializeMap = Impossible<(), fmt::Error>;
            type SerializeStruct = Impossible<(), fmt::Error>;
            type SerializeStructVariant = Impossible<(), fmt::Error>;
            fn serialize_bool(self, v: bool) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_i8(self, v: i8) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_i16(self, v: i16) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_i32(self, v: i32) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_i64(self, v: i64) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_i128(self, v: i128) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_u8(self, v: u8) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_u16(self, v: u16) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_u32(self, v: u32) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_u64(self, v: u64) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_u128(self, v: u128) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_f32(self, v: f32) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_f64(self, v: f64) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_char(self, v: char) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_str(self, v: &str) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_unit_struct(self, v: &'static str) -> fmt::Result {
                Display::fmt(&v, self)
            }
            fn serialize_unit_variant(self, _name: &'static str,
                _variant_index: u32, variant: &'static str) -> fmt::Result {
                Display::fmt(variant, self)
            }
            fn serialize_newtype_struct<T>(self, _name: &'static str,
                value: &T) -> fmt::Result where T: ?Sized + Serialize {
                Serialize::serialize(value, self)
            }
            fn serialize_bytes(self, _v: &[u8]) -> fmt::Result {
                Err(fmt::Error)
            }
            fn serialize_none(self) -> fmt::Result { Err(fmt::Error) }
            fn serialize_some<T>(self, _value: &T) -> fmt::Result where
                T: ?Sized + Serialize {
                Err(fmt::Error)
            }
            fn serialize_unit(self) -> fmt::Result { Err(fmt::Error) }
            fn serialize_newtype_variant<T>(self, _name: &'static str,
                _variant_index: u32, _variant: &'static str, _value: &T)
                -> fmt::Result where T: ?Sized + Serialize {
                Err(fmt::Error)
            }
            fn serialize_seq(self, _len: Option<usize>)
                -> Result<Self::SerializeSeq, fmt::Error> {
                Err(fmt::Error)
            }
            fn serialize_tuple(self, _len: usize)
                -> Result<Self::SerializeTuple, fmt::Error> {
                Err(fmt::Error)
            }
            fn serialize_tuple_struct(self, _name: &'static str, _len: usize)
                -> Result<Self::SerializeTupleStruct, fmt::Error> {
                Err(fmt::Error)
            }
            fn serialize_tuple_variant(self, _name: &'static str,
                _variant_index: u32, _variant: &'static str, _len: usize)
                -> Result<Self::SerializeTupleVariant, fmt::Error> {
                Err(fmt::Error)
            }
            fn serialize_map(self, _len: Option<usize>)
                -> Result<Self::SerializeMap, fmt::Error> {
                Err(fmt::Error)
            }
            fn serialize_struct(self, _name: &'static str, _len: usize)
                -> Result<Self::SerializeStruct, fmt::Error> {
                Err(fmt::Error)
            }
            fn serialize_struct_variant(self, _name: &'static str,
                _variant_index: u32, _variant: &'static str, _len: usize)
                -> Result<Self::SerializeStructVariant, fmt::Error> {
                Err(fmt::Error)
            }
            fn collect_str<T>(self, value: &T) -> fmt::Result where
                T: ?Sized + Display {
                Display::fmt(value, self)
            }
        }
    }
    mod impls {
        use crate::lib::*;
        use crate::ser::{Error, Serialize, SerializeTuple, Serializer};
        macro_rules! primitive_impl {
            ($ty:ident, $method:ident $($cast:tt)*) =>
            {
                impl Serialize for $ty
                {
                    #[inline] fn serialize<S>(&self, serializer: S) ->
                    Result<S::Ok, S::Error> where S: Serializer,
                    { serializer.$method(*self $($cast)*) }
                }
            }
        }
        impl Serialize for bool {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_bool(*self)
            }
        }
        impl Serialize for isize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_i64(*self as i64)
            }
        }
        impl Serialize for i8 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_i8(*self)
            }
        }
        impl Serialize for i16 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_i16(*self)
            }
        }
        impl Serialize for i32 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_i32(*self)
            }
        }
        impl Serialize for i64 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_i64(*self)
            }
        }
        impl Serialize for i128 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_i128(*self)
            }
        }
        impl Serialize for usize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_u64(*self as u64)
            }
        }
        impl Serialize for u8 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_u8(*self)
            }
        }
        impl Serialize for u16 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_u16(*self)
            }
        }
        impl Serialize for u32 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_u32(*self)
            }
        }
        impl Serialize for u64 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_u64(*self)
            }
        }
        impl Serialize for u128 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_u128(*self)
            }
        }
        impl Serialize for f32 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_f32(*self)
            }
        }
        impl Serialize for f64 {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_f64(*self)
            }
        }
        impl Serialize for char {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_char(*self)
            }
        }
        impl Serialize for str {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_str(self)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl Serialize for String {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_str(self)
            }
        }
        impl<'a> Serialize for fmt::Arguments<'a> {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_str(self)
            }
        }
        #[doc(cfg(feature = "std"))]
        impl Serialize for CStr {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_bytes(self.to_bytes())
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl Serialize for CString {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_bytes(self.to_bytes())
            }
        }
        impl<T> Serialize for Option<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                match *self {
                    Some(ref value) => serializer.serialize_some(value),
                    None => serializer.serialize_none(),
                }
            }
        }
        impl<T> Serialize for PhantomData<T> where T: ?Sized {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_unit_struct("PhantomData")
            }
        }
        impl<T> Serialize for [T; 0] {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                match serializer.serialize_tuple(0) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    }.end()
            }
        }
        macro_rules! array_impls {
            ($($len:tt)+) =>
            {
                $(impl<T> Serialize for [T; $len] where T: Serialize,
                {
                    #[inline] fn serialize<S>(&self, serializer: S) ->
                    Result<S::Ok, S::Error> where S: Serializer,
                    {
                        let mut seq = tri!(serializer.serialize_tuple($len)); for e
                        in self { tri!(seq.serialize_element(e)); } seq.end()
                    }
                })+
            }
        }
        impl<T> Serialize for [T; 01] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(01) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 02] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(02) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 03] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(03) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 04] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(04) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 05] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(05) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 06] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(06) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 07] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(07) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 08] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(08) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 09] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(09) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 10] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(10) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 11] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(11) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 12] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(12) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 13] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(13) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 14] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(14) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 15] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(15) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 16] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(16) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 17] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(17) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 18] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(18) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 19] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(19) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 20] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(20) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 21] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(21) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 22] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(22) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 23] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(23) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 24] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(24) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 25] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(25) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 26] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(26) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 27] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(27) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 28] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(28) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 29] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(29) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 30] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(30) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 31] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(31) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T; 32] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut seq =
                    match serializer.serialize_tuple(32) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                for e in self {
                    match seq.serialize_element(e) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                }
                seq.end()
            }
        }
        impl<T> Serialize for [T] where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_seq(self)
            }
        }
        macro_rules! seq_impl {
            ($(#[$attr:meta])* $ty:ident <T
            $(, $typaram:ident : $bound:ident)*>) =>
            {
                $(#[$attr])* impl<T $(, $typaram)*> Serialize for $ty<T
                $(, $typaram)*> where T: Serialize,
                {
                    #[inline] fn serialize<S>(&self, serializer: S) ->
                    Result<S::Ok, S::Error> where S: Serializer,
                    { serializer.collect_seq(self) }
                }
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<T> Serialize for BinaryHeap<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_seq(self)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<T> Serialize for BTreeSet<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_seq(self)
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<T, H> Serialize for HashSet<T, H> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_seq(self)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<T> Serialize for LinkedList<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_seq(self)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<T> Serialize for Vec<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_seq(self)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<T> Serialize for VecDeque<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_seq(self)
            }
        }
        impl<Idx> Serialize for Range<Idx> where Idx: Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                use super::SerializeStruct;
                let mut state =
                    match serializer.serialize_struct("Range", 2) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match state.serialize_field("start", &self.start) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match state.serialize_field("end", &self.end) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                state.end()
            }
        }
        impl<Idx> Serialize for RangeFrom<Idx> where Idx: Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                use super::SerializeStruct;
                let mut state =
                    match serializer.serialize_struct("RangeFrom", 1) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match state.serialize_field("start", &self.start) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                state.end()
            }
        }
        impl<Idx> Serialize for RangeInclusive<Idx> where Idx: Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                use super::SerializeStruct;
                let mut state =
                    match serializer.serialize_struct("RangeInclusive", 2) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match state.serialize_field("start", &self.start()) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match state.serialize_field("end", &self.end()) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                state.end()
            }
        }
        impl<Idx> Serialize for RangeTo<Idx> where Idx: Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                use super::SerializeStruct;
                let mut state =
                    match serializer.serialize_struct("RangeTo", 1) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match state.serialize_field("end", &self.end) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                state.end()
            }
        }
        impl<T> Serialize for Bound<T> where T: Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                match *self {
                    Bound::Unbounded =>
                        serializer.serialize_unit_variant("Bound", 0, "Unbounded"),
                    Bound::Included(ref value) => {
                        serializer.serialize_newtype_variant("Bound", 1, "Included",
                            value)
                    }
                    Bound::Excluded(ref value) => {
                        serializer.serialize_newtype_variant("Bound", 2, "Excluded",
                            value)
                    }
                }
            }
        }
        impl Serialize for () {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.serialize_unit()
            }
        }
        #[doc(cfg(feature = "unstable"))]
        impl Serialize for ! {
            fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                *self
            }
        }
        macro_rules! tuple_impls {
            ($($len:expr => ($($n:tt $name:ident)+))+) =>
            {
                $(#[cfg_attr(docsrs, doc(hidden))] impl<$($name),+> Serialize
                for ($($name,)+) where $($name: Serialize,)+
                { tuple_impl_body!($len => ($($n)+)); })+
            };
        }
        macro_rules! tuple_impl_body {
            ($len:expr => ($($n:tt)+)) =>
            {
                #[inline] fn serialize<S>(&self, serializer: S) ->
                Result<S::Ok, S::Error> where S: Serializer,
                {
                    let mut tuple = tri!(serializer.serialize_tuple($len));
                    $(tri!(tuple.serialize_element(&self.$n));)+ tuple.end()
                }
            };
        }
        #[doc(fake_variadic)]
        #[doc = "This trait is implemented for tuples up to 16 items long."]
        impl<T> Serialize for (T,) where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(1) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1> Serialize for (T0, T1) where T0: Serialize, T1: Serialize
            {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(2) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2> Serialize for (T0, T1, T2) where T0: Serialize,
            T1: Serialize, T2: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(3) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3) where
            T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(4) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4> Serialize for (T0, T1, T2, T3, T4) where
            T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,
            T4: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(5) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5> Serialize for (T0, T1, T2, T3, T4, T5)
            where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,
            T4: Serialize, T5: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(6) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6> Serialize for
            (T0, T1, T2, T3, T4, T5, T6) where T0: Serialize, T1: Serialize,
            T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize,
            T6: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(7) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7> Serialize for
            (T0, T1, T2, T3, T4, T5, T6, T7) where T0: Serialize,
            T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize,
            T5: Serialize, T6: Serialize, T7: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(8) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialize for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8) where T0: Serialize,
            T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize,
            T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(9) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.8) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialize for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where T0: Serialize,
            T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize,
            T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize,
            T9: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(10) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.8) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.9) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialize for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where T0: Serialize,
            T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize,
            T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize,
            T9: Serialize, T10: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(11) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.8) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.9) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.10) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialize for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
            T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,
            T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize,
            T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(12) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.8) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.9) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.10) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.11) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Serialize
            for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
            T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,
            T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize,
            T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize,
            T12: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(13) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.8) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.9) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.10) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.11) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.12) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
            Serialize for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
            T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,
            T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize,
            T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize,
            T12: Serialize, T13: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(14) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.8) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.9) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.10) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.11) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.12) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.13) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
            Serialize for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
            where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,
            T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize,
            T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize,
            T12: Serialize, T13: Serialize, T14: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(15) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.8) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.9) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.10) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.11) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.12) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.13) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.14) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        #[doc(hidden)]
        impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
            T15> Serialize for
            (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
            T15) where T0: Serialize, T1: Serialize, T2: Serialize,
            T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize,
            T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize,
            T11: Serialize, T12: Serialize, T13: Serialize, T14: Serialize,
            T15: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                let mut tuple =
                    match serializer.serialize_tuple(16) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match tuple.serialize_element(&self.0) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.1) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.2) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.3) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.4) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.5) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.6) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.7) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.8) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.9) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.10) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.11) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.12) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.13) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.14) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match tuple.serialize_element(&self.15) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                tuple.end()
            }
        }
        macro_rules! map_impl {
            ($(#[$attr:meta])* $ty:ident <K
            $(: $kbound1:ident $(+ $kbound2:ident)*)*, V
            $(, $typaram:ident : $bound:ident)*>) =>
            {
                $(#[$attr])* impl<K, V $(, $typaram)*> Serialize for $ty<K, V
                $(, $typaram)*> where K: Serialize, V: Serialize,
                {
                    #[inline] fn serialize<S>(&self, serializer: S) ->
                    Result<S::Ok, S::Error> where S: Serializer,
                    { serializer.collect_map(self) }
                }
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<K, V> Serialize for BTreeMap<K, V> where K: Serialize,
            V: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_map(self)
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<K, V, H> Serialize for HashMap<K, V, H> where K: Serialize,
            V: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                serializer.collect_map(self)
            }
        }
        macro_rules! deref_impl {
            ($(#[$attr:meta])* <$($desc:tt)+) =>
            {
                $(#[$attr])* impl <$($desc)+
                {
                    #[inline] fn serialize<S>(&self, serializer: S) ->
                    Result<S::Ok, S::Error> where S: Serializer,
                    { (**self).serialize(serializer) }
                }
            };
        }
        impl<'a, T> Serialize for &'a T where T: ?Sized + Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                (**self).serialize(serializer)
            }
        }
        impl<'a, T> Serialize for &'a mut T where T: ?Sized + Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                (**self).serialize(serializer)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<T> Serialize for Box<T> where T: ?Sized + Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                (**self).serialize(serializer)
            }
        }
        #[doc = r#" This impl requires the [`"rc"`] Cargo feature of Serde."#]
        #[doc = r""]
        #[doc =
        r" Serializing a data structure containing `Rc` will serialize a copy of"]
        #[doc =
        r" the contents of the `Rc` each time the `Rc` is referenced within the"]
        #[doc =
        r" data structure. Serialization will not attempt to deduplicate these"]
        #[doc = r" repeated data."]
        #[doc = r""]
        #[doc =
        r#" [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc"#]
        #[doc(cfg(all(feature = "rc",
        any(feature = "std", feature = "alloc"))))]
        impl<T> Serialize for Rc<T> where T: ?Sized + Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                (**self).serialize(serializer)
            }
        }
        #[doc = r#" This impl requires the [`"rc"`] Cargo feature of Serde."#]
        #[doc = r""]
        #[doc =
        r" Serializing a data structure containing `Arc` will serialize a copy of"]
        #[doc =
        r" the contents of the `Arc` each time the `Arc` is referenced within the"]
        #[doc =
        r" data structure. Serialization will not attempt to deduplicate these"]
        #[doc = r" repeated data."]
        #[doc = r""]
        #[doc =
        r#" [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc"#]
        #[doc(cfg(all(feature = "rc",
        any(feature = "std", feature = "alloc"))))]
        impl<T> Serialize for Arc<T> where T: ?Sized + Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                (**self).serialize(serializer)
            }
        }
        #[doc(cfg(any(feature = "std", feature = "alloc")))]
        impl<'a, T> Serialize for Cow<'a, T> where T: ?Sized + Serialize +
            ToOwned {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                (**self).serialize(serializer)
            }
        }
        /// This impl requires the [`"rc"`] Cargo feature of Serde.
        ///
        /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
        #[doc(cfg(all(feature = "rc",
        any(feature = "std", feature = "alloc"))))]
        impl<T> Serialize for RcWeak<T> where T: ?Sized + Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.upgrade().serialize(serializer)
            }
        }
        /// This impl requires the [`"rc"`] Cargo feature of Serde.
        ///
        /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
        #[doc(cfg(all(feature = "rc",
        any(feature = "std", feature = "alloc"))))]
        impl<T> Serialize for ArcWeak<T> where T: ?Sized + Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.upgrade().serialize(serializer)
            }
        }
        macro_rules! nonzero_integers {
            ($($T:ident,)+) =>
            {
                $(impl Serialize for num::$T
                {
                    fn serialize<S>(&self, serializer: S) -> Result<S::Ok,
                    S::Error> where S: Serializer,
                    { self.get().serialize(serializer) }
                })+
            }
        }
        impl Serialize for num::NonZeroI8 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroI16 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroI32 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroI64 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroI128 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroIsize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroU8 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroU16 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroU32 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroU64 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroU128 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl Serialize for num::NonZeroUsize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl<T> Serialize for Cell<T> where T: Serialize + Copy {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.get().serialize(serializer)
            }
        }
        impl<T> Serialize for RefCell<T> where T: ?Sized + Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                match self.try_borrow() {
                    Ok(value) => value.serialize(serializer),
                    Err(_) => Err(S::Error::custom("already mutably borrowed")),
                }
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<T> Serialize for Mutex<T> where T: ?Sized + Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                match self.lock() {
                    Ok(locked) => locked.serialize(serializer),
                    Err(_) =>
                        Err(S::Error::custom("lock poison error while serializing")),
                }
            }
        }
        #[doc(cfg(feature = "std"))]
        impl<T> Serialize for RwLock<T> where T: ?Sized + Serialize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                match self.read() {
                    Ok(locked) => locked.serialize(serializer),
                    Err(_) =>
                        Err(S::Error::custom("lock poison error while serializing")),
                }
            }
        }
        #[doc(cfg(feature = "result"))]
        impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize
            {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                match *self {
                    Result::Ok(ref value) =>
                        serializer.serialize_newtype_variant("Result", 0, "Ok",
                            value),
                    Result::Err(ref value) => {
                        serializer.serialize_newtype_variant("Result", 1, "Err",
                            value)
                    }
                }
            }
        }
        impl Serialize for Duration {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                use super::SerializeStruct;
                let mut state =
                    match serializer.serialize_struct("Duration", 2) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match state.serialize_field("secs", &self.as_secs()) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match state.serialize_field("nanos", &self.subsec_nanos()) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                state.end()
            }
        }
        #[doc(cfg(feature = "std"))]
        impl Serialize for SystemTime {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                use super::SerializeStruct;
                let duration_since_epoch =
                    match self.duration_since(UNIX_EPOCH) {
                        Ok(duration_since_epoch) => duration_since_epoch,
                        Err(_) =>
                            return Err(S::Error::custom("SystemTime must be later than UNIX_EPOCH")),
                    };
                let mut state =
                    match serializer.serialize_struct("SystemTime", 2) {
                        Ok(val) => val,
                        Err(err) => return Err(err),
                    };
                match state.serialize_field("secs_since_epoch",
                        &duration_since_epoch.as_secs()) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                match state.serialize_field("nanos_since_epoch",
                        &duration_since_epoch.subsec_nanos()) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
                state.end()
            }
        }
        /// Serialize a value that implements `Display` as a string, when that string is
        /// statically known to never have more than a constant `MAX_LEN` bytes.
        ///
        /// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes.
        macro_rules! serialize_display_bounded_length {
            ($value:expr, $max:expr, $serializer:expr) =>
            {{
                    let mut buffer = [0u8; $max]; let mut writer =
                    crate::format::Buf::new(&mut buffer);
                    write!(&mut writer, "{}", $value).unwrap();
                    $serializer.serialize_str(writer.as_str())
                }};
        }
        impl Serialize for net::IpAddr {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                if serializer.is_human_readable() {
                    match *self {
                        net::IpAddr::V4(ref a) => a.serialize(serializer),
                        net::IpAddr::V6(ref a) => a.serialize(serializer),
                    }
                } else {
                    match *self {
                        net::IpAddr::V4(ref a) => {
                            serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
                        }
                        net::IpAddr::V6(ref a) => {
                            serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
                        }
                    }
                }
            }
        }
        const DEC_DIGITS_LUT: &[u8] =
            b"\
      0001020304050607080910111213141516171819\
      2021222324252627282930313233343536373839\
      4041424344454647484950515253545556575859\
      6061626364656667686970717273747576777879\
      8081828384858687888990919293949596979899";
        #[inline]
        fn format_u8(mut n: u8, out: &mut [u8]) -> usize {
            if n >= 100 {
                let d1 = ((n % 100) << 1) as usize;
                n /= 100;
                out[0] = b'0' + n;
                out[1] = DEC_DIGITS_LUT[d1];
                out[2] = DEC_DIGITS_LUT[d1 + 1];
                3
            } else if n >= 10 {
                let d1 = (n << 1) as usize;
                out[0] = DEC_DIGITS_LUT[d1];
                out[1] = DEC_DIGITS_LUT[d1 + 1];
                2
            } else { out[0] = b'0' + n; 1 }
        }
        impl Serialize for net::Ipv4Addr {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                if serializer.is_human_readable() {
                    const MAX_LEN: usize = 15;
                    if true {
                        match (&MAX_LEN, &"101.102.103.104".len()) {
                            (left_val, right_val) => {
                                if !(*left_val == *right_val) {
                                    let kind = ::core::panicking::AssertKind::Eq;
                                    ::core::panicking::assert_failed(kind, &*left_val,
                                        &*right_val, ::core::option::Option::None);
                                }
                            }
                        };
                    };
                    let mut buf = [b'.'; MAX_LEN];
                    let mut written = format_u8(self.octets()[0], &mut buf);
                    for oct in &self.octets()[1..] {
                        written += format_u8(*oct, &mut buf[written + 1..]) + 1;
                    }
                    let buf =
                        unsafe { str::from_utf8_unchecked(&buf[..written]) };
                    serializer.serialize_str(buf)
                } else { self.octets().serialize(serializer) }
            }
        }
        impl Serialize for net::Ipv6Addr {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                if serializer.is_human_readable() {
                    const MAX_LEN: usize = 39;
                    if true {
                        match (&MAX_LEN,
                                &"1001:1002:1003:1004:1005:1006:1007:1008".len()) {
                            (left_val, right_val) => {
                                if !(*left_val == *right_val) {
                                    let kind = ::core::panicking::AssertKind::Eq;
                                    ::core::panicking::assert_failed(kind, &*left_val,
                                        &*right_val, ::core::option::Option::None);
                                }
                            }
                        };
                    };
                    {
                        let mut buffer = [0u8; MAX_LEN];
                        let mut writer = crate::format::Buf::new(&mut buffer);
                        (&mut writer).write_fmt(format_args!("{0}", self)).unwrap();
                        serializer.serialize_str(writer.as_str())
                    }
                } else { self.octets().serialize(serializer) }
            }
        }
        impl Serialize for net::SocketAddr {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                if serializer.is_human_readable() {
                    match *self {
                        net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
                        net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
                    }
                } else {
                    match *self {
                        net::SocketAddr::V4(ref addr) => {
                            serializer.serialize_newtype_variant("SocketAddr", 0, "V4",
                                addr)
                        }
                        net::SocketAddr::V6(ref addr) => {
                            serializer.serialize_newtype_variant("SocketAddr", 1, "V6",
                                addr)
                        }
                    }
                }
            }
        }
        impl Serialize for net::SocketAddrV4 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                if serializer.is_human_readable() {
                    const MAX_LEN: usize = 21;
                    if true {
                        match (&MAX_LEN, &"101.102.103.104:65000".len()) {
                            (left_val, right_val) => {
                                if !(*left_val == *right_val) {
                                    let kind = ::core::panicking::AssertKind::Eq;
                                    ::core::panicking::assert_failed(kind, &*left_val,
                                        &*right_val, ::core::option::Option::None);
                                }
                            }
                        };
                    };
                    {
                        let mut buffer = [0u8; MAX_LEN];
                        let mut writer = crate::format::Buf::new(&mut buffer);
                        (&mut writer).write_fmt(format_args!("{0}", self)).unwrap();
                        serializer.serialize_str(writer.as_str())
                    }
                } else { (self.ip(), self.port()).serialize(serializer) }
            }
        }
        impl Serialize for net::SocketAddrV6 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                if serializer.is_human_readable() {
                    const MAX_LEN: usize = 58;
                    if true {
                        match (&MAX_LEN,
                                &"[1001:1002:1003:1004:1005:1006:1007:1008%4294967295]:65000".len())
                            {
                            (left_val, right_val) => {
                                if !(*left_val == *right_val) {
                                    let kind = ::core::panicking::AssertKind::Eq;
                                    ::core::panicking::assert_failed(kind, &*left_val,
                                        &*right_val, ::core::option::Option::None);
                                }
                            }
                        };
                    };
                    {
                        let mut buffer = [0u8; MAX_LEN];
                        let mut writer = crate::format::Buf::new(&mut buffer);
                        (&mut writer).write_fmt(format_args!("{0}", self)).unwrap();
                        serializer.serialize_str(writer.as_str())
                    }
                } else { (self.ip(), self.port()).serialize(serializer) }
            }
        }
        #[doc(cfg(feature = "std"))]
        impl Serialize for Path {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                match self.to_str() {
                    Some(s) => s.serialize(serializer),
                    None =>
                        Err(Error::custom("path contains invalid UTF-8 characters")),
                }
            }
        }
        #[doc(cfg(feature = "std"))]
        impl Serialize for PathBuf {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.as_path().serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", any(unix, windows))))]
        impl Serialize for OsStr {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                use std::os::unix::ffi::OsStrExt;
                serializer.serialize_newtype_variant("OsString", 0, "Unix",
                    self.as_bytes())
            }
        }
        #[doc(cfg(all(feature = "std", any(unix, windows))))]
        impl Serialize for OsString {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.as_os_str().serialize(serializer)
            }
        }
        impl<T> Serialize for Wrapping<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.0.serialize(serializer)
            }
        }
        impl<T> Serialize for Saturating<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.0.serialize(serializer)
            }
        }
        impl<T> Serialize for Reverse<T> where T: Serialize {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.0.serialize(serializer)
            }
        }
        macro_rules! atomic_impl {
            ($($ty:ident $size:expr)*) =>
            {
                $(#[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
                #[cfg_attr(docsrs,
                doc(cfg(all(feature = "std", target_has_atomic = $size))))]
                impl Serialize for $ty
                {
                    fn serialize<S>(&self, serializer: S) -> Result<S::Ok,
                    S::Error> where S: Serializer,
                    { self.load(Ordering::Relaxed).serialize(serializer) }
                })*
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "8")))]
        impl Serialize for AtomicBool {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "8")))]
        impl Serialize for AtomicI8 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "16")))]
        impl Serialize for AtomicI16 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "32")))]
        impl Serialize for AtomicI32 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "ptr")))]
        impl Serialize for AtomicIsize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "8")))]
        impl Serialize for AtomicU8 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "16")))]
        impl Serialize for AtomicU16 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "32")))]
        impl Serialize for AtomicU32 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "ptr")))]
        impl Serialize for AtomicUsize {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "64")))]
        impl Serialize for AtomicI64 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
        #[doc(cfg(all(feature = "std", target_has_atomic = "64")))]
        impl Serialize for AtomicU64 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where S: Serializer {
                self.load(Ordering::Relaxed).serialize(serializer)
            }
        }
    }
    mod impossible {
        //! This module contains `Impossible` serializer and its implementations.
        use crate::lib::*;
        use crate::ser::{
            self, Serialize, SerializeMap, SerializeSeq, SerializeStruct,
            SerializeStructVariant, SerializeTuple, SerializeTupleStruct,
            SerializeTupleVariant,
        };
        /// Helper type for implementing a `Serializer` that does not support
        /// serializing one of the compound types.
        ///
        /// This type cannot be instantiated, but implements every one of the traits
        /// corresponding to the [`Serializer`] compound types: [`SerializeSeq`],
        /// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`],
        /// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`].
        ///
        /// ```edition2021
        /// # use serde::ser::{Serializer, Impossible};
        /// # use serde_core::__private::doc::Error;
        /// #
        /// # struct MySerializer;
        /// #
        /// impl Serializer for MySerializer {
        ///     type Ok = ();
        ///     type Error = Error;
        ///
        ///     type SerializeSeq = Impossible<(), Error>;
        ///     /* other associated types */
        ///
        ///     /// This data format does not support serializing sequences.
        ///     fn serialize_seq(self,
        ///                      len: Option<usize>)
        ///                      -> Result<Self::SerializeSeq, Error> {
        ///         // Given Impossible cannot be instantiated, the only
        ///         // thing we can do here is to return an error.
        /// #         stringify! {
        ///         Err(...)
        /// #         };
        /// #         unimplemented!()
        ///     }
        ///
        ///     /* other Serializer methods */
        /// #     serde_core::__serialize_unimplemented! {
        /// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some
        /// #         unit unit_struct unit_variant newtype_struct newtype_variant
        /// #         tuple tuple_struct tuple_variant map struct struct_variant
        /// #     }
        /// }
        /// ```
        ///
        /// [`Serializer`]: crate::Serializer
        /// [`SerializeSeq`]: crate::ser::SerializeSeq
        /// [`SerializeTuple`]: crate::ser::SerializeTuple
        /// [`SerializeTupleStruct`]: crate::ser::SerializeTupleStruct
        /// [`SerializeTupleVariant`]: crate::ser::SerializeTupleVariant
        /// [`SerializeMap`]: crate::ser::SerializeMap
        /// [`SerializeStruct`]: crate::ser::SerializeStruct
        /// [`SerializeStructVariant`]: crate::ser::SerializeStructVariant
        pub struct Impossible<Ok, Error> {
            void: Void,
            ok: PhantomData<Ok>,
            error: PhantomData<Error>,
        }
        enum Void {}
        impl<Ok, Error> SerializeSeq for Impossible<Ok, Error> where
            Error: ser::Error {
            type Ok = Ok;
            type Error = Error;
            fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
                where T: ?Sized + Serialize {
                let _ = value;
                match self.void {}
            }
            fn end(self) -> Result<Ok, Error> { match self.void {} }
        }
        impl<Ok, Error> SerializeTuple for Impossible<Ok, Error> where
            Error: ser::Error {
            type Ok = Ok;
            type Error = Error;
            fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
                where T: ?Sized + Serialize {
                let _ = value;
                match self.void {}
            }
            fn end(self) -> Result<Ok, Error> { match self.void {} }
        }
        impl<Ok, Error> SerializeTupleStruct for Impossible<Ok, Error> where
            Error: ser::Error {
            type Ok = Ok;
            type Error = Error;
            fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
                where T: ?Sized + Serialize {
                let _ = value;
                match self.void {}
            }
            fn end(self) -> Result<Ok, Error> { match self.void {} }
        }
        impl<Ok, Error> SerializeTupleVariant for Impossible<Ok, Error> where
            Error: ser::Error {
            type Ok = Ok;
            type Error = Error;
            fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
                where T: ?Sized + Serialize {
                let _ = value;
                match self.void {}
            }
            fn end(self) -> Result<Ok, Error> { match self.void {} }
        }
        impl<Ok, Error> SerializeMap for Impossible<Ok, Error> where
            Error: ser::Error {
            type Ok = Ok;
            type Error = Error;
            fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error> where
                T: ?Sized + Serialize {
                let _ = key;
                match self.void {}
            }
            fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
                where T: ?Sized + Serialize {
                let _ = value;
                match self.void {}
            }
            fn end(self) -> Result<Ok, Error> { match self.void {} }
        }
        impl<Ok, Error> SerializeStruct for Impossible<Ok, Error> where
            Error: ser::Error {
            type Ok = Ok;
            type Error = Error;
            fn serialize_field<T>(&mut self, key: &'static str, value: &T)
                -> Result<(), Error> where T: ?Sized + Serialize {
                let _ = key;
                let _ = value;
                match self.void {}
            }
            fn end(self) -> Result<Ok, Error> { match self.void {} }
        }
        impl<Ok, Error> SerializeStructVariant for Impossible<Ok, Error> where
            Error: ser::Error {
            type Ok = Ok;
            type Error = Error;
            fn serialize_field<T>(&mut self, key: &'static str, value: &T)
                -> Result<(), Error> where T: ?Sized + Serialize {
                let _ = key;
                let _ = value;
                match self.void {}
            }
            fn end(self) -> Result<Ok, Error> { match self.void {} }
        }
    }
    pub use self::impossible::Impossible;
    #[doc(no_inline)]
    pub use std::error::Error as StdError;
    macro_rules! declare_error_trait {
        (Error: Sized $(+ $($supertrait:ident)::+)*) =>
        {
            /// Trait used by `Serialize` implementations to generically construct
            /// errors belonging to the `Serializer` against which they are
            /// currently running.
            ///
            /// # Example implementation
            ///
            /// The [example data format] presented on the website shows an error
            /// type appropriate for a basic JSON data format.
            ///
            /// [example data format]: https://serde.rs/data-format.html
            #[cfg_attr(not(no_diagnostic_namespace),
            diagnostic::on_unimplemented(message =
            "the trait bound `{Self}: serde::ser::Error` is not satisfied",))]
            pub trait Error: Sized $(+ $($supertrait)::+)*
            {
                /// Used when a [`Serialize`] implementation encounters any error
                /// while serializing a type.
                ///
                /// The message should not be capitalized and should not end with a
                /// period.
                ///
                /// For example, a filesystem [`Path`] may refuse to serialize
                /// itself if it contains invalid UTF-8 data.
                ///
                /// ```edition2021
                /// # struct Path;
                /// #
                /// # impl Path {
                /// #     fn to_str(&self) -> Option<&str> {
                /// #         unimplemented!()
                /// #     }
                /// # }
                /// #
                /// use serde::ser::{self, Serialize, Serializer};
                ///
                /// impl Serialize for Path {
                ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                ///     where
                ///         S: Serializer,
                ///     {
                ///         match self.to_str() {
                ///             Some(s) => serializer.serialize_str(s),
                ///             None => Err(ser::Error::custom("path contains invalid UTF-8 characters")),
                ///         }
                ///     }
                /// }
                /// ```
                ///
                /// [`Path`]: std::path::Path
                /// [`Serialize`]: crate::Serialize
                fn custom<T>(msg: T) -> Self where T: Display;
            }
        }
    }
    /// Trait used by `Serialize` implementations to generically construct
    /// errors belonging to the `Serializer` against which they are
    /// currently running.
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website shows an error
    /// type appropriate for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::ser::Error` is not satisfied",)]
    pub trait Error: Sized + StdError {
        /// Used when a [`Serialize`] implementation encounters any error
        /// while serializing a type.
        ///
        /// The message should not be capitalized and should not end with a
        /// period.
        ///
        /// For example, a filesystem [`Path`] may refuse to serialize
        /// itself if it contains invalid UTF-8 data.
        ///
        /// ```edition2021
        /// # struct Path;
        /// #
        /// # impl Path {
        /// #     fn to_str(&self) -> Option<&str> {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// use serde::ser::{self, Serialize, Serializer};
        ///
        /// impl Serialize for Path {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         match self.to_str() {
        ///             Some(s) => serializer.serialize_str(s),
        ///             None => Err(ser::Error::custom("path contains invalid UTF-8 characters")),
        ///         }
        ///     }
        /// }
        /// ```
        ///
        /// [`Path`]: std::path::Path
        /// [`Serialize`]: crate::Serialize
        fn custom<T>(msg: T)
        -> Self
        where
        T: Display;
    }
    /// A **data structure** that can be serialized into any data format supported
    /// by Serde.
    ///
    /// Serde provides `Serialize` implementations for many Rust primitive and
    /// standard library types. The complete list is [here][crate::ser]. All of
    /// these can be serialized using Serde out of the box.
    ///
    /// Additionally, Serde provides a procedural macro called [`serde_derive`] to
    /// automatically generate `Serialize` implementations for structs and enums in
    /// your program. See the [derive section of the manual] for how to use this.
    ///
    /// In rare cases it may be necessary to implement `Serialize` manually for some
    /// type in your program. See the [Implementing `Serialize`] section of the
    /// manual for more about this.
    ///
    /// Third-party crates may provide `Serialize` implementations for types that
    /// they expose. For example the [`linked-hash-map`] crate provides a
    /// [`LinkedHashMap<K, V>`] type that is serializable by Serde because the crate
    /// provides an implementation of `Serialize` for it.
    ///
    /// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
    /// [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
    /// [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
    /// [`serde_derive`]: https://crates.io/crates/serde_derive
    /// [derive section of the manual]: https://serde.rs/derive.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::Serialize` is not satisfied", note =
    "for local types consider adding `#[derive(serde::Serialize)]` to your `{Self}` type",
    note =
    "for types from other crates check whether the crate offers a `serde` feature flag",)]
    pub trait Serialize {
        /// Serialize this value into the given Serde serializer.
        ///
        /// See the [Implementing `Serialize`] section of the manual for more
        /// information about how to implement this method.
        ///
        /// ```edition2021
        /// use serde::ser::{Serialize, SerializeStruct, Serializer};
        ///
        /// struct Person {
        ///     name: String,
        ///     age: u8,
        ///     phones: Vec<String>,
        /// }
        ///
        /// // This is what #[derive(Serialize)] would generate.
        /// impl Serialize for Person {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         let mut s = serializer.serialize_struct("Person", 3)?;
        ///         s.serialize_field("name", &self.name)?;
        ///         s.serialize_field("age", &self.age)?;
        ///         s.serialize_field("phones", &self.phones)?;
        ///         s.end()
        ///     }
        /// }
        /// ```
        ///
        /// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
        fn serialize<S>(&self, serializer: S)
        -> Result<S::Ok, S::Error>
        where
        S: Serializer;
    }
    /// A **data format** that can serialize any data structure supported by Serde.
    ///
    /// The role of this trait is to define the serialization half of the [Serde
    /// data model], which is a way to categorize every Rust data structure into one
    /// of 29 possible types. Each method of the `Serializer` trait corresponds to
    /// one of the types of the data model.
    ///
    /// Implementations of `Serialize` map themselves into this data model by
    /// invoking exactly one of the `Serializer` methods.
    ///
    /// The types that make up the Serde data model are:
    ///
    ///  - **14 primitive types**
    ///    - bool
    ///    - i8, i16, i32, i64, i128
    ///    - u8, u16, u32, u64, u128
    ///    - f32, f64
    ///    - char
    ///  - **string**
    ///    - UTF-8 bytes with a length and no null terminator.
    ///    - When serializing, all strings are handled equally. When deserializing,
    ///      there are three flavors of strings: transient, owned, and borrowed.
    ///  - **byte array** - \[u8\]
    ///    - Similar to strings, during deserialization byte arrays can be
    ///      transient, owned, or borrowed.
    ///  - **option**
    ///    - Either none or some value.
    ///  - **unit**
    ///    - The type of `()` in Rust. It represents an anonymous value containing
    ///      no data.
    ///  - **unit_struct**
    ///    - For example `struct Unit` or `PhantomData<T>`. It represents a named
    ///      value containing no data.
    ///  - **unit_variant**
    ///    - For example the `E::A` and `E::B` in `enum E { A, B }`.
    ///  - **newtype_struct**
    ///    - For example `struct Millimeters(u8)`.
    ///  - **newtype_variant**
    ///    - For example the `E::N` in `enum E { N(u8) }`.
    ///  - **seq**
    ///    - A variably sized heterogeneous sequence of values, for example
    ///      `Vec<T>` or `HashSet<T>`. When serializing, the length may or may not
    ///      be known before iterating through all the data. When deserializing,
    ///      the length is determined by looking at the serialized data.
    ///  - **tuple**
    ///    - A statically sized heterogeneous sequence of values for which the
    ///      length will be known at deserialization time without looking at the
    ///      serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or
    ///      `[u64; 10]`.
    ///  - **tuple_struct**
    ///    - A named tuple, for example `struct Rgb(u8, u8, u8)`.
    ///  - **tuple_variant**
    ///    - For example the `E::T` in `enum E { T(u8, u8) }`.
    ///  - **map**
    ///    - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
    ///  - **struct**
    ///    - A heterogeneous key-value pairing in which the keys are strings and
    ///      will be known at deserialization time without looking at the
    ///      serialized data, for example `struct S { r: u8, g: u8, b: u8 }`.
    ///  - **struct_variant**
    ///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
    ///
    /// Many Serde serializers produce text or binary data as output, for example
    /// JSON or Postcard. This is not a requirement of the `Serializer` trait, and
    /// there are serializers that do not produce text or binary output. One example
    /// is the `serde_json::value::Serializer` (distinct from the main `serde_json`
    /// serializer) that produces a `serde_json::Value` data structure in memory as
    /// output.
    ///
    /// [Serde data model]: https://serde.rs/data-model.html
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website contains example code for
    /// a basic JSON `Serializer`.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::Serializer` is not satisfied",)]
    pub trait Serializer: Sized {
        /// The output type produced by this `Serializer` during successful
        /// serialization. Most serializers that produce text or binary output
        /// should set `Ok = ()` and serialize into an [`io::Write`] or buffer
        /// contained within the `Serializer` instance. Serializers that build
        /// in-memory data structures may be simplified by using `Ok` to propagate
        /// the data structure around.
        ///
        /// [`io::Write`]: std::io::Write
        type Ok;
        /// The error type when some error occurs during serialization.
        type Error: Error;
        /// Type returned from [`serialize_seq`] for serializing the content of the
        /// sequence.
        ///
        /// [`serialize_seq`]: #tymethod.serialize_seq
        type SerializeSeq: SerializeSeq<Ok = Self::Ok, Error = Self::Error>;
        /// Type returned from [`serialize_tuple`] for serializing the content of
        /// the tuple.
        ///
        /// [`serialize_tuple`]: #tymethod.serialize_tuple
        type
            SerializeTuple: SerializeTuple<Ok = Self::Ok, Error =
            Self::Error>;
        /// Type returned from [`serialize_tuple_struct`] for serializing the
        /// content of the tuple struct.
        ///
        /// [`serialize_tuple_struct`]: #tymethod.serialize_tuple_struct
        type
            SerializeTupleStruct: SerializeTupleStruct<Ok = Self::Ok, Error =
            Self::Error>;
        /// Type returned from [`serialize_tuple_variant`] for serializing the
        /// content of the tuple variant.
        ///
        /// [`serialize_tuple_variant`]: #tymethod.serialize_tuple_variant
        type
            SerializeTupleVariant: SerializeTupleVariant<Ok = Self::Ok, Error
            = Self::Error>;
        /// Type returned from [`serialize_map`] for serializing the content of the
        /// map.
        ///
        /// [`serialize_map`]: #tymethod.serialize_map
        type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>;
        /// Type returned from [`serialize_struct`] for serializing the content of
        /// the struct.
        ///
        /// [`serialize_struct`]: #tymethod.serialize_struct
        type
            SerializeStruct: SerializeStruct<Ok = Self::Ok, Error =
            Self::Error>;
        /// Type returned from [`serialize_struct_variant`] for serializing the
        /// content of the struct variant.
        ///
        /// [`serialize_struct_variant`]: #tymethod.serialize_struct_variant
        type
            SerializeStructVariant: SerializeStructVariant<Ok = Self::Ok,
            Error = Self::Error>;
        /// Serialize a `bool` value.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for bool {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_bool(*self)
        ///     }
        /// }
        /// ```
        fn serialize_bool(self, v: bool)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize an `i8` value.
        ///
        /// If the format does not differentiate between `i8` and `i64`, a
        /// reasonable implementation would be to cast the value to `i64` and
        /// forward to `serialize_i64`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for i8 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_i8(*self)
        ///     }
        /// }
        /// ```
        fn serialize_i8(self, v: i8)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize an `i16` value.
        ///
        /// If the format does not differentiate between `i16` and `i64`, a
        /// reasonable implementation would be to cast the value to `i64` and
        /// forward to `serialize_i64`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for i16 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_i16(*self)
        ///     }
        /// }
        /// ```
        fn serialize_i16(self, v: i16)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize an `i32` value.
        ///
        /// If the format does not differentiate between `i32` and `i64`, a
        /// reasonable implementation would be to cast the value to `i64` and
        /// forward to `serialize_i64`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for i32 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_i32(*self)
        ///     }
        /// }
        /// ```
        fn serialize_i32(self, v: i32)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize an `i64` value.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for i64 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_i64(*self)
        ///     }
        /// }
        /// ```
        fn serialize_i64(self, v: i64)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize an `i128` value.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for i128 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_i128(*self)
        ///     }
        /// }
        /// ```
        ///
        /// The default behavior unconditionally returns an error.
        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
            let _ = v;
            Err(Error::custom("i128 is not supported"))
        }
        /// Serialize a `u8` value.
        ///
        /// If the format does not differentiate between `u8` and `u64`, a
        /// reasonable implementation would be to cast the value to `u64` and
        /// forward to `serialize_u64`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for u8 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_u8(*self)
        ///     }
        /// }
        /// ```
        fn serialize_u8(self, v: u8)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a `u16` value.
        ///
        /// If the format does not differentiate between `u16` and `u64`, a
        /// reasonable implementation would be to cast the value to `u64` and
        /// forward to `serialize_u64`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for u16 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_u16(*self)
        ///     }
        /// }
        /// ```
        fn serialize_u16(self, v: u16)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a `u32` value.
        ///
        /// If the format does not differentiate between `u32` and `u64`, a
        /// reasonable implementation would be to cast the value to `u64` and
        /// forward to `serialize_u64`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for u32 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_u32(*self)
        ///     }
        /// }
        /// ```
        fn serialize_u32(self, v: u32)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a `u64` value.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for u64 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_u64(*self)
        ///     }
        /// }
        /// ```
        fn serialize_u64(self, v: u64)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a `u128` value.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for u128 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_u128(*self)
        ///     }
        /// }
        /// ```
        ///
        /// The default behavior unconditionally returns an error.
        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
            let _ = v;
            Err(Error::custom("u128 is not supported"))
        }
        /// Serialize an `f32` value.
        ///
        /// If the format does not differentiate between `f32` and `f64`, a
        /// reasonable implementation would be to cast the value to `f64` and
        /// forward to `serialize_f64`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for f32 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_f32(*self)
        ///     }
        /// }
        /// ```
        fn serialize_f32(self, v: f32)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize an `f64` value.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for f64 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_f64(*self)
        ///     }
        /// }
        /// ```
        fn serialize_f64(self, v: f64)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a character.
        ///
        /// If the format does not support characters, it is reasonable to serialize
        /// it as a single element `str` or a `u32`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for char {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_char(*self)
        ///     }
        /// }
        /// ```
        fn serialize_char(self, v: char)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a `&str`.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for str {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_str(self)
        ///     }
        /// }
        /// ```
        fn serialize_str(self, v: &str)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a chunk of raw byte data.
        ///
        /// Enables serializers to serialize byte slices more compactly or more
        /// efficiently than other types of slices. If no efficient implementation
        /// is available, a reasonable implementation would be to forward to
        /// `serialize_seq`. If forwarded, the implementation looks usually just
        /// like this:
        ///
        /// ```edition2021
        /// # use serde::ser::{Serializer, SerializeSeq};
        /// # use serde_core::__private::doc::Error;
        /// #
        /// # struct MySerializer;
        /// #
        /// # impl Serializer for MySerializer {
        /// #     type Ok = ();
        /// #     type Error = Error;
        /// #
        /// fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        ///     let mut seq = self.serialize_seq(Some(v.len()))?;
        ///     for b in v {
        ///         seq.serialize_element(b)?;
        ///     }
        ///     seq.end()
        /// }
        /// #
        /// #     serde_core::__serialize_unimplemented! {
        /// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str none some
        /// #         unit unit_struct unit_variant newtype_struct newtype_variant
        /// #         seq tuple tuple_struct tuple_variant map struct struct_variant
        /// #     }
        /// # }
        /// ```
        fn serialize_bytes(self, v: &[u8])
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a [`None`] value.
        ///
        /// ```edition2021
        /// # use serde::{Serialize, Serializer};
        /// #
        /// # enum Option<T> {
        /// #     Some(T),
        /// #     None,
        /// # }
        /// #
        /// # use self::Option::{Some, None};
        /// #
        /// impl<T> Serialize for Option<T>
        /// where
        ///     T: Serialize,
        /// {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         match *self {
        ///             Some(ref value) => serializer.serialize_some(value),
        ///             None => serializer.serialize_none(),
        ///         }
        ///     }
        /// }
        /// #
        /// # fn main() {}
        /// ```
        ///
        /// [`None`]: core::option::Option::None
        fn serialize_none(self)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a [`Some(T)`] value.
        ///
        /// ```edition2021
        /// # use serde::{Serialize, Serializer};
        /// #
        /// # enum Option<T> {
        /// #     Some(T),
        /// #     None,
        /// # }
        /// #
        /// # use self::Option::{Some, None};
        /// #
        /// impl<T> Serialize for Option<T>
        /// where
        ///     T: Serialize,
        /// {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         match *self {
        ///             Some(ref value) => serializer.serialize_some(value),
        ///             None => serializer.serialize_none(),
        ///         }
        ///     }
        /// }
        /// #
        /// # fn main() {}
        /// ```
        ///
        /// [`Some(T)`]: core::option::Option::Some
        fn serialize_some<T>(self, value: &T)
        -> Result<Self::Ok, Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Serialize a `()` value.
        ///
        /// ```edition2021
        /// # use serde::Serializer;
        /// #
        /// # serde_core::__private_serialize!();
        /// #
        /// impl Serialize for () {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_unit()
        ///     }
        /// }
        /// ```
        fn serialize_unit(self)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a unit struct like `struct Unit` or `PhantomData<T>`.
        ///
        /// A reasonable implementation would be to forward to `serialize_unit`.
        ///
        /// ```edition2021
        /// use serde::{Serialize, Serializer};
        ///
        /// struct Nothing;
        ///
        /// impl Serialize for Nothing {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_unit_struct("Nothing")
        ///     }
        /// }
        /// ```
        fn serialize_unit_struct(self, name: &'static str)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a unit variant like `E::A` in `enum E { A, B }`.
        ///
        /// The `name` is the name of the enum, the `variant_index` is the index of
        /// this variant within the enum, and the `variant` is the name of the
        /// variant.
        ///
        /// ```edition2021
        /// use serde::{Serialize, Serializer};
        ///
        /// enum E {
        ///     A,
        ///     B,
        /// }
        ///
        /// impl Serialize for E {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         match *self {
        ///             E::A => serializer.serialize_unit_variant("E", 0, "A"),
        ///             E::B => serializer.serialize_unit_variant("E", 1, "B"),
        ///         }
        ///     }
        /// }
        /// ```
        fn serialize_unit_variant(self, name: &'static str,
        variant_index: u32, variant: &'static str)
        -> Result<Self::Ok, Self::Error>;
        /// Serialize a newtype struct like `struct Millimeters(u8)`.
        ///
        /// Serializers are encouraged to treat newtype structs as insignificant
        /// wrappers around the data they contain. A reasonable implementation would
        /// be to forward to `value.serialize(self)`.
        ///
        /// ```edition2021
        /// use serde::{Serialize, Serializer};
        ///
        /// struct Millimeters(u8);
        ///
        /// impl Serialize for Millimeters {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.serialize_newtype_struct("Millimeters", &self.0)
        ///     }
        /// }
        /// ```
        fn serialize_newtype_struct<T>(self, name: &'static str, value: &T)
        -> Result<Self::Ok, Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.
        ///
        /// The `name` is the name of the enum, the `variant_index` is the index of
        /// this variant within the enum, and the `variant` is the name of the
        /// variant. The `value` is the data contained within this newtype variant.
        ///
        /// ```edition2021
        /// use serde::{Serialize, Serializer};
        ///
        /// enum E {
        ///     M(String),
        ///     N(u8),
        /// }
        ///
        /// impl Serialize for E {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         match *self {
        ///             E::M(ref s) => serializer.serialize_newtype_variant("E", 0, "M", s),
        ///             E::N(n) => serializer.serialize_newtype_variant("E", 1, "N", &n),
        ///         }
        ///     }
        /// }
        /// ```
        fn serialize_newtype_variant<T>(self, name: &'static str,
        variant_index: u32, variant: &'static str, value: &T)
        -> Result<Self::Ok, Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Begin to serialize a variably sized sequence. This call must be
        /// followed by zero or more calls to `serialize_element`, then a call to
        /// `end`.
        ///
        /// The argument is the number of elements in the sequence, which may or may
        /// not be computable before the sequence is iterated. Some serializers only
        /// support sequences whose length is known up front.
        ///
        /// ```edition2021
        /// # use std::marker::PhantomData;
        /// #
        /// # struct Vec<T>(PhantomData<T>);
        /// #
        /// # impl<T> Vec<T> {
        /// #     fn len(&self) -> usize {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// # impl<'a, T> IntoIterator for &'a Vec<T> {
        /// #     type Item = &'a T;
        /// #     type IntoIter = Box<dyn Iterator<Item = &'a T>>;
        /// #
        /// #     fn into_iter(self) -> Self::IntoIter {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// use serde::ser::{Serialize, SerializeSeq, Serializer};
        ///
        /// impl<T> Serialize for Vec<T>
        /// where
        ///     T: Serialize,
        /// {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         let mut seq = serializer.serialize_seq(Some(self.len()))?;
        ///         for element in self {
        ///             seq.serialize_element(element)?;
        ///         }
        ///         seq.end()
        ///     }
        /// }
        /// ```
        fn serialize_seq(self, len: Option<usize>)
        -> Result<Self::SerializeSeq, Self::Error>;
        /// Begin to serialize a statically sized sequence whose length will be
        /// known at deserialization time without looking at the serialized data.
        /// This call must be followed by zero or more calls to `serialize_element`,
        /// then a call to `end`.
        ///
        /// ```edition2021
        /// use serde::ser::{Serialize, SerializeTuple, Serializer};
        ///
        /// # mod fool {
        /// #     trait Serialize {}
        /// impl<A, B, C> Serialize for (A, B, C)
        /// #     {}
        /// # }
        /// #
        /// # struct Tuple3<A, B, C>(A, B, C);
        /// #
        /// # impl<A, B, C> Serialize for Tuple3<A, B, C>
        /// where
        ///     A: Serialize,
        ///     B: Serialize,
        ///     C: Serialize,
        /// {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         let mut tup = serializer.serialize_tuple(3)?;
        ///         tup.serialize_element(&self.0)?;
        ///         tup.serialize_element(&self.1)?;
        ///         tup.serialize_element(&self.2)?;
        ///         tup.end()
        ///     }
        /// }
        /// ```
        ///
        /// ```edition2021
        /// use serde::ser::{Serialize, SerializeTuple, Serializer};
        ///
        /// const VRAM_SIZE: usize = 386;
        /// struct Vram([u16; VRAM_SIZE]);
        ///
        /// impl Serialize for Vram {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         let mut seq = serializer.serialize_tuple(VRAM_SIZE)?;
        ///         for element in &self.0[..] {
        ///             seq.serialize_element(element)?;
        ///         }
        ///         seq.end()
        ///     }
        /// }
        /// ```
        fn serialize_tuple(self, len: usize)
        -> Result<Self::SerializeTuple, Self::Error>;
        /// Begin to serialize a tuple struct like `struct Rgb(u8, u8, u8)`. This
        /// call must be followed by zero or more calls to `serialize_field`, then a
        /// call to `end`.
        ///
        /// The `name` is the name of the tuple struct and the `len` is the number
        /// of data fields that will be serialized.
        ///
        /// ```edition2021
        /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
        ///
        /// struct Rgb(u8, u8, u8);
        ///
        /// impl Serialize for Rgb {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
        ///         ts.serialize_field(&self.0)?;
        ///         ts.serialize_field(&self.1)?;
        ///         ts.serialize_field(&self.2)?;
        ///         ts.end()
        ///     }
        /// }
        /// ```
        fn serialize_tuple_struct(self, name: &'static str, len: usize)
        -> Result<Self::SerializeTupleStruct, Self::Error>;
        /// Begin to serialize a tuple variant like `E::T` in `enum E { T(u8, u8)
        /// }`. This call must be followed by zero or more calls to
        /// `serialize_field`, then a call to `end`.
        ///
        /// The `name` is the name of the enum, the `variant_index` is the index of
        /// this variant within the enum, the `variant` is the name of the variant,
        /// and the `len` is the number of data fields that will be serialized.
        ///
        /// ```edition2021
        /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
        ///
        /// enum E {
        ///     T(u8, u8),
        ///     U(String, u32, u32),
        /// }
        ///
        /// impl Serialize for E {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         match *self {
        ///             E::T(ref a, ref b) => {
        ///                 let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
        ///                 tv.serialize_field(a)?;
        ///                 tv.serialize_field(b)?;
        ///                 tv.end()
        ///             }
        ///             E::U(ref a, ref b, ref c) => {
        ///                 let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
        ///                 tv.serialize_field(a)?;
        ///                 tv.serialize_field(b)?;
        ///                 tv.serialize_field(c)?;
        ///                 tv.end()
        ///             }
        ///         }
        ///     }
        /// }
        /// ```
        fn serialize_tuple_variant(self, name: &'static str,
        variant_index: u32, variant: &'static str, len: usize)
        -> Result<Self::SerializeTupleVariant, Self::Error>;
        /// Begin to serialize a map. This call must be followed by zero or more
        /// calls to `serialize_key` and `serialize_value`, then a call to `end`.
        ///
        /// The argument is the number of elements in the map, which may or may not
        /// be computable before the map is iterated. Some serializers only support
        /// maps whose length is known up front.
        ///
        /// ```edition2021
        /// # use std::marker::PhantomData;
        /// #
        /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
        /// #
        /// # impl<K, V> HashMap<K, V> {
        /// #     fn len(&self) -> usize {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// # impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {
        /// #     type Item = (&'a K, &'a V);
        /// #     type IntoIter = Box<dyn Iterator<Item = (&'a K, &'a V)>>;
        /// #
        /// #     fn into_iter(self) -> Self::IntoIter {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// use serde::ser::{Serialize, SerializeMap, Serializer};
        ///
        /// impl<K, V> Serialize for HashMap<K, V>
        /// where
        ///     K: Serialize,
        ///     V: Serialize,
        /// {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         let mut map = serializer.serialize_map(Some(self.len()))?;
        ///         for (k, v) in self {
        ///             map.serialize_entry(k, v)?;
        ///         }
        ///         map.end()
        ///     }
        /// }
        /// ```
        fn serialize_map(self, len: Option<usize>)
        -> Result<Self::SerializeMap, Self::Error>;
        /// Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`.
        /// This call must be followed by zero or more calls to `serialize_field`,
        /// then a call to `end`.
        ///
        /// The `name` is the name of the struct and the `len` is the number of
        /// data fields that will be serialized. `len` does not include fields
        /// which are skipped with [`SerializeStruct::skip_field`].
        ///
        /// ```edition2021
        /// use serde::ser::{Serialize, SerializeStruct, Serializer};
        ///
        /// struct Rgb {
        ///     r: u8,
        ///     g: u8,
        ///     b: u8,
        /// }
        ///
        /// impl Serialize for Rgb {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;
        ///         rgb.serialize_field("r", &self.r)?;
        ///         rgb.serialize_field("g", &self.g)?;
        ///         rgb.serialize_field("b", &self.b)?;
        ///         rgb.end()
        ///     }
        /// }
        /// ```
        fn serialize_struct(self, name: &'static str, len: usize)
        -> Result<Self::SerializeStruct, Self::Error>;
        /// Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8,
        /// g: u8, b: u8 } }`. This call must be followed by zero or more calls to
        /// `serialize_field`, then a call to `end`.
        ///
        /// The `name` is the name of the enum, the `variant_index` is the index of
        /// this variant within the enum, the `variant` is the name of the variant,
        /// and the `len` is the number of data fields that will be serialized.
        /// `len` does not include fields which are skipped with
        /// [`SerializeStructVariant::skip_field`].
        ///
        /// ```edition2021
        /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
        ///
        /// enum E {
        ///     S { r: u8, g: u8, b: u8 },
        /// }
        ///
        /// impl Serialize for E {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         match *self {
        ///             E::S {
        ///                 ref r,
        ///                 ref g,
        ///                 ref b,
        ///             } => {
        ///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
        ///                 sv.serialize_field("r", r)?;
        ///                 sv.serialize_field("g", g)?;
        ///                 sv.serialize_field("b", b)?;
        ///                 sv.end()
        ///             }
        ///         }
        ///     }
        /// }
        /// ```
        fn serialize_struct_variant(self, name: &'static str,
        variant_index: u32, variant: &'static str, len: usize)
        -> Result<Self::SerializeStructVariant, Self::Error>;
        /// Collect an iterator as a sequence.
        ///
        /// The default implementation serializes each item yielded by the iterator
        /// using [`serialize_seq`]. Implementors should not need to override this
        /// method.
        ///
        /// ```edition2021
        /// use serde::{Serialize, Serializer};
        ///
        /// struct SecretlyOneHigher {
        ///     data: Vec<i32>,
        /// }
        ///
        /// impl Serialize for SecretlyOneHigher {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.collect_seq(self.data.iter().map(|x| x + 1))
        ///     }
        /// }
        /// ```
        ///
        /// [`serialize_seq`]: #tymethod.serialize_seq
        fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
            where I: IntoIterator, <I as IntoIterator>::Item: Serialize {
            let mut iter = iter.into_iter();
            let mut serializer =
                match self.serialize_seq(iterator_len_hint(&iter)) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
            match iter.try_for_each(|item|
                        serializer.serialize_element(&item)) {
                Ok(val) => val,
                Err(err) => return Err(err),
            };
            serializer.end()
        }
        /// Collect an iterator as a map.
        ///
        /// The default implementation serializes each pair yielded by the iterator
        /// using [`serialize_map`]. Implementors should not need to override this
        /// method.
        ///
        /// ```edition2021
        /// use serde::{Serialize, Serializer};
        /// use std::collections::BTreeSet;
        ///
        /// struct MapToUnit {
        ///     keys: BTreeSet<i32>,
        /// }
        ///
        /// // Serializes as a map in which the values are all unit.
        /// impl Serialize for MapToUnit {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.collect_map(self.keys.iter().map(|k| (k, ())))
        ///     }
        /// }
        /// ```
        ///
        /// [`serialize_map`]: #tymethod.serialize_map
        fn collect_map<K, V, I>(self, iter: I)
            -> Result<Self::Ok, Self::Error> where K: Serialize, V: Serialize,
            I: IntoIterator<Item = (K, V)> {
            let mut iter = iter.into_iter();
            let mut serializer =
                match self.serialize_map(iterator_len_hint(&iter)) {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                };
            match iter.try_for_each(|(key, value)|
                        serializer.serialize_entry(&key, &value)) {
                Ok(val) => val,
                Err(err) => return Err(err),
            };
            serializer.end()
        }
        /// Serialize a string produced by an implementation of `Display`.
        ///
        /// The default implementation builds a heap-allocated [`String`] and
        /// delegates to [`serialize_str`]. Serializers are encouraged to provide a
        /// more efficient implementation if possible.
        ///
        /// ```edition2021
        /// # struct DateTime;
        /// #
        /// # impl DateTime {
        /// #     fn naive_local(&self) -> () { () }
        /// #     fn offset(&self) -> () { () }
        /// # }
        /// #
        /// use serde::{Serialize, Serializer};
        ///
        /// impl Serialize for DateTime {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         serializer.collect_str(&format_args!("{:?}{:?}", self.naive_local(), self.offset()))
        ///     }
        /// }
        /// ```
        ///
        /// [`serialize_str`]: Self::serialize_str
        fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
            where T: ?Sized + Display {
            self.serialize_str(&value.to_string())
        }
        /// Determine whether `Serialize` implementations should serialize in
        /// human-readable form.
        ///
        /// Some types have a human-readable form that may be somewhat expensive to
        /// construct, as well as a binary form that is compact and efficient.
        /// Generally text-based formats like JSON and YAML will prefer to use the
        /// human-readable one and binary formats like Postcard will prefer the
        /// compact one.
        ///
        /// ```edition2021
        /// # use std::fmt::{self, Display};
        /// #
        /// # struct Timestamp;
        /// #
        /// # impl Timestamp {
        /// #     fn seconds_since_epoch(&self) -> u64 { unimplemented!() }
        /// # }
        /// #
        /// # impl Display for Timestamp {
        /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        /// #         unimplemented!()
        /// #     }
        /// # }
        /// #
        /// use serde::{Serialize, Serializer};
        ///
        /// impl Serialize for Timestamp {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        ///     where
        ///         S: Serializer,
        ///     {
        ///         if serializer.is_human_readable() {
        ///             // Serialize to a human-readable string "2015-05-15T17:01:00Z".
        ///             self.to_string().serialize(serializer)
        ///         } else {
        ///             // Serialize to a compact binary representation.
        ///             self.seconds_since_epoch().serialize(serializer)
        ///         }
        ///     }
        /// }
        /// ```
        ///
        /// The default implementation of this method returns `true`. Data formats
        /// may override this to `false` to request a compact form for types that
        /// support one. Note that modifying this method to change a format from
        /// human-readable to compact or vice versa should be regarded as a breaking
        /// change, as a value serialized in human-readable mode is not required to
        /// deserialize from the same data in compact mode.
        #[inline]
        fn is_human_readable(&self) -> bool { true }
    }
    /// Returned from `Serializer::serialize_seq`.
    ///
    /// # Example use
    ///
    /// ```edition2021
    /// # use std::marker::PhantomData;
    /// #
    /// # struct Vec<T>(PhantomData<T>);
    /// #
    /// # impl<T> Vec<T> {
    /// #     fn len(&self) -> usize {
    /// #         unimplemented!()
    /// #     }
    /// # }
    /// #
    /// # impl<'a, T> IntoIterator for &'a Vec<T> {
    /// #     type Item = &'a T;
    /// #     type IntoIter = Box<dyn Iterator<Item = &'a T>>;
    /// #     fn into_iter(self) -> Self::IntoIter {
    /// #         unimplemented!()
    /// #     }
    /// # }
    /// #
    /// use serde::ser::{Serialize, SerializeSeq, Serializer};
    ///
    /// impl<T> Serialize for Vec<T>
    /// where
    ///     T: Serialize,
    /// {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    ///     where
    ///         S: Serializer,
    ///     {
    ///         let mut seq = serializer.serialize_seq(Some(self.len()))?;
    ///         for element in self {
    ///             seq.serialize_element(element)?;
    ///         }
    ///         seq.end()
    ///     }
    /// }
    /// ```
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `SerializeSeq` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::ser::SerializeSeq` is not satisfied",)]
    pub trait SerializeSeq {
        /// Must match the `Ok` type of our `Serializer`.
        type Ok;
        /// Must match the `Error` type of our `Serializer`.
        type Error: Error;
        /// Serialize a sequence element.
        fn serialize_element<T>(&mut self, value: &T)
        -> Result<(), Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Finish serializing a sequence.
        fn end(self)
        -> Result<Self::Ok, Self::Error>;
    }
    /// Returned from `Serializer::serialize_tuple`.
    ///
    /// # Example use
    ///
    /// ```edition2021
    /// use serde::ser::{Serialize, SerializeTuple, Serializer};
    ///
    /// # mod fool {
    /// #     trait Serialize {}
    /// impl<A, B, C> Serialize for (A, B, C)
    /// #     {}
    /// # }
    /// #
    /// # struct Tuple3<A, B, C>(A, B, C);
    /// #
    /// # impl<A, B, C> Serialize for Tuple3<A, B, C>
    /// where
    ///     A: Serialize,
    ///     B: Serialize,
    ///     C: Serialize,
    /// {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    ///     where
    ///         S: Serializer,
    ///     {
    ///         let mut tup = serializer.serialize_tuple(3)?;
    ///         tup.serialize_element(&self.0)?;
    ///         tup.serialize_element(&self.1)?;
    ///         tup.serialize_element(&self.2)?;
    ///         tup.end()
    ///     }
    /// }
    /// ```
    ///
    /// ```edition2021
    /// # use std::marker::PhantomData;
    /// #
    /// # struct Array<T>(PhantomData<T>);
    /// #
    /// # impl<T> Array<T> {
    /// #     fn len(&self) -> usize {
    /// #         unimplemented!()
    /// #     }
    /// # }
    /// #
    /// # impl<'a, T> IntoIterator for &'a Array<T> {
    /// #     type Item = &'a T;
    /// #     type IntoIter = Box<dyn Iterator<Item = &'a T>>;
    /// #     fn into_iter(self) -> Self::IntoIter {
    /// #         unimplemented!()
    /// #     }
    /// # }
    /// #
    /// use serde::ser::{Serialize, SerializeTuple, Serializer};
    ///
    /// # mod fool {
    /// #     trait Serialize {}
    /// impl<T> Serialize for [T; 16]
    /// #     {}
    /// # }
    /// #
    /// # impl<T> Serialize for Array<T>
    /// where
    ///     T: Serialize,
    /// {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    ///     where
    ///         S: Serializer,
    ///     {
    ///         let mut seq = serializer.serialize_tuple(16)?;
    ///         for element in self {
    ///             seq.serialize_element(element)?;
    ///         }
    ///         seq.end()
    ///     }
    /// }
    /// ```
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `SerializeTuple` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::ser::SerializeTuple` is not satisfied",)]
    pub trait SerializeTuple {
        /// Must match the `Ok` type of our `Serializer`.
        type Ok;
        /// Must match the `Error` type of our `Serializer`.
        type Error: Error;
        /// Serialize a tuple element.
        fn serialize_element<T>(&mut self, value: &T)
        -> Result<(), Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Finish serializing a tuple.
        fn end(self)
        -> Result<Self::Ok, Self::Error>;
    }
    /// Returned from `Serializer::serialize_tuple_struct`.
    ///
    /// # Example use
    ///
    /// ```edition2021
    /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
    ///
    /// struct Rgb(u8, u8, u8);
    ///
    /// impl Serialize for Rgb {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    ///     where
    ///         S: Serializer,
    ///     {
    ///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
    ///         ts.serialize_field(&self.0)?;
    ///         ts.serialize_field(&self.1)?;
    ///         ts.serialize_field(&self.2)?;
    ///         ts.end()
    ///     }
    /// }
    /// ```
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `SerializeTupleStruct` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::ser::SerializeTupleStruct` is not satisfied",)]
    pub trait SerializeTupleStruct {
        /// Must match the `Ok` type of our `Serializer`.
        type Ok;
        /// Must match the `Error` type of our `Serializer`.
        type Error: Error;
        /// Serialize a tuple struct field.
        fn serialize_field<T>(&mut self, value: &T)
        -> Result<(), Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Finish serializing a tuple struct.
        fn end(self)
        -> Result<Self::Ok, Self::Error>;
    }
    /// Returned from `Serializer::serialize_tuple_variant`.
    ///
    /// # Example use
    ///
    /// ```edition2021
    /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
    ///
    /// enum E {
    ///     T(u8, u8),
    ///     U(String, u32, u32),
    /// }
    ///
    /// impl Serialize for E {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    ///     where
    ///         S: Serializer,
    ///     {
    ///         match *self {
    ///             E::T(ref a, ref b) => {
    ///                 let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
    ///                 tv.serialize_field(a)?;
    ///                 tv.serialize_field(b)?;
    ///                 tv.end()
    ///             }
    ///             E::U(ref a, ref b, ref c) => {
    ///                 let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
    ///                 tv.serialize_field(a)?;
    ///                 tv.serialize_field(b)?;
    ///                 tv.serialize_field(c)?;
    ///                 tv.end()
    ///             }
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `SerializeTupleVariant` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::ser::SerializeTupleVariant` is not satisfied",)]
    pub trait SerializeTupleVariant {
        /// Must match the `Ok` type of our `Serializer`.
        type Ok;
        /// Must match the `Error` type of our `Serializer`.
        type Error: Error;
        /// Serialize a tuple variant field.
        fn serialize_field<T>(&mut self, value: &T)
        -> Result<(), Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Finish serializing a tuple variant.
        fn end(self)
        -> Result<Self::Ok, Self::Error>;
    }
    /// Returned from `Serializer::serialize_map`.
    ///
    /// # Example use
    ///
    /// ```edition2021
    /// # use std::marker::PhantomData;
    /// #
    /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
    /// #
    /// # impl<K, V> HashMap<K, V> {
    /// #     fn len(&self) -> usize {
    /// #         unimplemented!()
    /// #     }
    /// # }
    /// #
    /// # impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {
    /// #     type Item = (&'a K, &'a V);
    /// #     type IntoIter = Box<dyn Iterator<Item = (&'a K, &'a V)>>;
    /// #
    /// #     fn into_iter(self) -> Self::IntoIter {
    /// #         unimplemented!()
    /// #     }
    /// # }
    /// #
    /// use serde::ser::{Serialize, SerializeMap, Serializer};
    ///
    /// impl<K, V> Serialize for HashMap<K, V>
    /// where
    ///     K: Serialize,
    ///     V: Serialize,
    /// {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    ///     where
    ///         S: Serializer,
    ///     {
    ///         let mut map = serializer.serialize_map(Some(self.len()))?;
    ///         for (k, v) in self {
    ///             map.serialize_entry(k, v)?;
    ///         }
    ///         map.end()
    ///     }
    /// }
    /// ```
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `SerializeMap` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::ser::SerializeMap` is not satisfied",)]
    pub trait SerializeMap {
        /// Must match the `Ok` type of our `Serializer`.
        type Ok;
        /// Must match the `Error` type of our `Serializer`.
        type Error: Error;
        /// Serialize a map key.
        ///
        /// If possible, `Serialize` implementations are encouraged to use
        /// `serialize_entry` instead as it may be implemented more efficiently in
        /// some formats compared to a pair of calls to `serialize_key` and
        /// `serialize_value`.
        fn serialize_key<T>(&mut self, key: &T)
        -> Result<(), Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Serialize a map value.
        ///
        /// # Panics
        ///
        /// Calling `serialize_value` before `serialize_key` is incorrect and is
        /// allowed to panic or produce bogus results.
        fn serialize_value<T>(&mut self, value: &T)
        -> Result<(), Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Serialize a map entry consisting of a key and a value.
        ///
        /// Some [`Serialize`] types are not able to hold a key and value in memory
        /// at the same time so `SerializeMap` implementations are required to
        /// support [`serialize_key`] and [`serialize_value`] individually. The
        /// `serialize_entry` method allows serializers to optimize for the case
        /// where key and value are both available. [`Serialize`] implementations
        /// are encouraged to use `serialize_entry` if possible.
        ///
        /// The default implementation delegates to [`serialize_key`] and
        /// [`serialize_value`]. This is appropriate for serializers that do not
        /// care about performance or are not able to optimize `serialize_entry` any
        /// better than this.
        ///
        /// [`Serialize`]: crate::Serialize
        /// [`serialize_key`]: Self::serialize_key
        /// [`serialize_value`]: Self::serialize_value
        fn serialize_entry<K, V>(&mut self, key: &K, value: &V)
            -> Result<(), Self::Error> where K: ?Sized + Serialize,
            V: ?Sized + Serialize {
            match self.serialize_key(key) {
                Ok(val) => val,
                Err(err) => return Err(err),
            };
            self.serialize_value(value)
        }
        /// Finish serializing a map.
        fn end(self)
        -> Result<Self::Ok, Self::Error>;
    }
    /// Returned from `Serializer::serialize_struct`.
    ///
    /// # Example use
    ///
    /// ```edition2021
    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
    ///
    /// struct Rgb {
    ///     r: u8,
    ///     g: u8,
    ///     b: u8,
    /// }
    ///
    /// impl Serialize for Rgb {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    ///     where
    ///         S: Serializer,
    ///     {
    ///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;
    ///         rgb.serialize_field("r", &self.r)?;
    ///         rgb.serialize_field("g", &self.g)?;
    ///         rgb.serialize_field("b", &self.b)?;
    ///         rgb.end()
    ///     }
    /// }
    /// ```
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `SerializeStruct` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::ser::SerializeStruct` is not satisfied",)]
    pub trait SerializeStruct {
        /// Must match the `Ok` type of our `Serializer`.
        type Ok;
        /// Must match the `Error` type of our `Serializer`.
        type Error: Error;
        /// Serialize a struct field.
        fn serialize_field<T>(&mut self, key: &'static str, value: &T)
        -> Result<(), Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Indicate that a struct field has been skipped.
        ///
        /// The default implementation does nothing.
        #[inline]
        fn skip_field(&mut self, key: &'static str)
            -> Result<(), Self::Error> {
            let _ = key;
            Ok(())
        }
        /// Finish serializing a struct.
        fn end(self)
        -> Result<Self::Ok, Self::Error>;
    }
    /// Returned from `Serializer::serialize_struct_variant`.
    ///
    /// # Example use
    ///
    /// ```edition2021
    /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
    ///
    /// enum E {
    ///     S { r: u8, g: u8, b: u8 },
    /// }
    ///
    /// impl Serialize for E {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    ///     where
    ///         S: Serializer,
    ///     {
    ///         match *self {
    ///             E::S {
    ///                 ref r,
    ///                 ref g,
    ///                 ref b,
    ///             } => {
    ///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
    ///                 sv.serialize_field("r", r)?;
    ///                 sv.serialize_field("g", g)?;
    ///                 sv.serialize_field("b", b)?;
    ///                 sv.end()
    ///             }
    ///         }
    ///     }
    /// }
    /// ```
    ///
    /// # Example implementation
    ///
    /// The [example data format] presented on the website demonstrates an
    /// implementation of `SerializeStructVariant` for a basic JSON data format.
    ///
    /// [example data format]: https://serde.rs/data-format.html
    #[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::ser::SerializeStructVariant` is not satisfied",)]
    pub trait SerializeStructVariant {
        /// Must match the `Ok` type of our `Serializer`.
        type Ok;
        /// Must match the `Error` type of our `Serializer`.
        type Error: Error;
        /// Serialize a struct variant field.
        fn serialize_field<T>(&mut self, key: &'static str, value: &T)
        -> Result<(), Self::Error>
        where
        T: ?Sized +
        Serialize;
        /// Indicate that a struct variant field has been skipped.
        ///
        /// The default implementation does nothing.
        #[inline]
        fn skip_field(&mut self, key: &'static str)
            -> Result<(), Self::Error> {
            let _ = key;
            Ok(())
        }
        /// Finish serializing a struct variant.
        fn end(self)
        -> Result<Self::Ok, Self::Error>;
    }
    fn iterator_len_hint<I>(iter: &I) -> Option<usize> where I: Iterator {
        match iter.size_hint() {
            (lo, Some(hi)) if lo == hi => Some(lo),
            _ => None,
        }
    }
}
mod format {
    use crate::lib::fmt::{self, Write};
    use crate::lib::str;
    pub(super) struct Buf<'a> {
        bytes: &'a mut [u8],
        offset: usize,
    }
    impl<'a> Buf<'a> {
        pub fn new(bytes: &'a mut [u8]) -> Self { Buf { bytes, offset: 0 } }
        pub fn as_str(&self) -> &str {
            let slice = &self.bytes[..self.offset];
            unsafe { str::from_utf8_unchecked(slice) }
        }
    }
    impl<'a> Write for Buf<'a> {
        fn write_str(&mut self, s: &str) -> fmt::Result {
            if self.offset + s.len() > self.bytes.len() {
                Err(fmt::Error)
            } else {
                self.bytes[self.offset..self.offset +
                                s.len()].copy_from_slice(s.as_bytes());
                self.offset += s.len();
                Ok(())
            }
        }
    }
}
#[doc(inline)]
pub use crate::de::{Deserialize, Deserializer};
#[doc(inline)]
pub use crate::ser::{Serialize, Serializer};
#[doc(hidden)]
mod private {
    mod content {
        use crate::lib::*;
        #[doc(hidden)]
        pub enum Content<'de> {
            Bool(bool),
            U8(u8),
            U16(u16),
            U32(u32),
            U64(u64),
            I8(i8),
            I16(i16),
            I32(i32),
            I64(i64),
            F32(f32),
            F64(f64),
            Char(char),
            String(String),
            Str(&'de str),
            ByteBuf(Vec<u8>),
            Bytes(&'de [u8]),
            None,
            Some(Box<Content<'de>>),
            Unit,
            Newtype(Box<Content<'de>>),
            Seq(Vec<Content<'de>>),
            Map(Vec<(Content<'de>, Content<'de>)>),
        }
    }
    mod seed {
        use crate::de::{Deserialize, DeserializeSeed, Deserializer};
        /// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
        ///
        /// Wraps a mutable reference and calls deserialize_in_place on it.
        pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
        #[diagnostic::do_not_recommend]
        impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T> where
            T: Deserialize<'de> {
            type Value = ();
            fn deserialize<D>(self, deserializer: D)
                -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
                T::deserialize_in_place(deserializer, self.0)
            }
        }
    }
    #[doc(hidden)]
    pub mod doc {
        use crate::lib::*;
        use crate::ser;
        #[doc(hidden)]
        pub struct Error;
        #[automatically_derived]
        impl ::core::fmt::Debug for Error {
            #[inline]
            fn fmt(&self, f: &mut ::core::fmt::Formatter)
                -> ::core::fmt::Result {
                ::core::fmt::Formatter::write_str(f, "Error")
            }
        }
        #[diagnostic::do_not_recommend]
        impl ser::Error for Error {
            fn custom<T>(_: T) -> Self where T: Display {
                ::core::panicking::panic("not implemented")
            }
        }
        #[diagnostic::do_not_recommend]
        impl error::Error for Error {
            fn description(&self) -> &str {
                ::core::panicking::panic("not implemented")
            }
        }
        #[diagnostic::do_not_recommend]
        impl Display for Error {
            fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
                ::core::panicking::panic("not implemented")
            }
        }
        #[doc(hidden)]
        #[macro_export]
        macro_rules! __private_serialize {
            () =>
            {
                trait Serialize
                {
                    fn serialize<S>(&self, serializer: S) -> Result<S::Ok,
                    S::Error> where S: $crate::Serializer;
                }
            };
        }
        #[doc(hidden)]
        #[macro_export(local_inner_macros)]
        macro_rules! __serialize_unimplemented {
            ($($func:ident)*) =>
            { $(__serialize_unimplemented_helper!($func);)* };
        }
        #[doc(hidden)]
        #[macro_export]
        macro_rules! __serialize_unimplemented_method {
            ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) =>
            {
                fn $func $(<$t>)* (self $(, _: $arg)*) ->
                $crate::__private::Result<Self::$ret, Self::Error> where
                $($t: ?Sized + $crate::Serialize,)* { unimplemented!() }
            };
        }
        #[doc(hidden)]
        #[macro_export(local_inner_macros)]
        macro_rules! __serialize_unimplemented_helper {
            (bool) =>
            {
                __serialize_unimplemented_method!(serialize_bool(bool) -> Ok);
            }; (i8) =>
            { __serialize_unimplemented_method!(serialize_i8(i8) -> Ok); };
            (i16) =>
            { __serialize_unimplemented_method!(serialize_i16(i16) -> Ok); };
            (i32) =>
            { __serialize_unimplemented_method!(serialize_i32(i32) -> Ok); };
            (i64) =>
            { __serialize_unimplemented_method!(serialize_i64(i64) -> Ok); };
            (u8) =>
            { __serialize_unimplemented_method!(serialize_u8(u8) -> Ok); };
            (u16) =>
            { __serialize_unimplemented_method!(serialize_u16(u16) -> Ok); };
            (u32) =>
            { __serialize_unimplemented_method!(serialize_u32(u32) -> Ok); };
            (u64) =>
            { __serialize_unimplemented_method!(serialize_u64(u64) -> Ok); };
            (f32) =>
            { __serialize_unimplemented_method!(serialize_f32(f32) -> Ok); };
            (f64) =>
            { __serialize_unimplemented_method!(serialize_f64(f64) -> Ok); };
            (char) =>
            {
                __serialize_unimplemented_method!(serialize_char(char) -> Ok);
            }; (str) =>
            { __serialize_unimplemented_method!(serialize_str(&str) -> Ok); };
            (bytes) =>
            {
                __serialize_unimplemented_method!(serialize_bytes(&[u8]) ->
                Ok);
            }; (none) =>
            { __serialize_unimplemented_method!(serialize_none() -> Ok); };
            (some) =>
            {
                __serialize_unimplemented_method!(serialize_some<T>(&T) ->
                Ok);
            }; (unit) =>
            { __serialize_unimplemented_method!(serialize_unit() -> Ok); };
            (unit_struct) =>
            {
                __serialize_unimplemented_method!(serialize_unit_struct(&str)
                -> Ok);
            }; (unit_variant) =>
            {
                __serialize_unimplemented_method!(serialize_unit_variant(&str,
                u32, &str) -> Ok);
            }; (newtype_struct) =>
            {
                __serialize_unimplemented_method!(serialize_newtype_struct<T>(&str,
                &T) -> Ok);
            }; (newtype_variant) =>
            {
                __serialize_unimplemented_method!(serialize_newtype_variant<T>(&str,
                u32, &str, &T) -> Ok);
            }; (seq) =>
            {
                type SerializeSeq = $crate::ser::Impossible<Self::Ok,
                Self::Error>;
                __serialize_unimplemented_method!(serialize_seq(Option<usize>)
                -> SerializeSeq);
            }; (tuple) =>
            {
                type SerializeTuple = $crate::ser::Impossible<Self::Ok,
                Self::Error>;
                __serialize_unimplemented_method!(serialize_tuple(usize) ->
                SerializeTuple);
            }; (tuple_struct) =>
            {
                type SerializeTupleStruct = $crate::ser::Impossible<Self::Ok,
                Self::Error>;
                __serialize_unimplemented_method!(serialize_tuple_struct(&str,
                usize) -> SerializeTupleStruct);
            }; (tuple_variant) =>
            {
                type SerializeTupleVariant = $crate::ser::Impossible<Self::Ok,
                Self::Error>;
                __serialize_unimplemented_method!(serialize_tuple_variant(&str,
                u32, &str, usize) -> SerializeTupleVariant);
            }; (map) =>
            {
                type SerializeMap = $crate::ser::Impossible<Self::Ok,
                Self::Error>;
                __serialize_unimplemented_method!(serialize_map(Option<usize>)
                -> SerializeMap);
            }; (struct) =>
            {
                type SerializeStruct = $crate::ser::Impossible<Self::Ok,
                Self::Error>;
                __serialize_unimplemented_method!(serialize_struct(&str,
                usize) -> SerializeStruct);
            }; (struct_variant) =>
            {
                type SerializeStructVariant =
                $crate::ser::Impossible<Self::Ok, Self::Error>;
                __serialize_unimplemented_method!(serialize_struct_variant(&str,
                u32, &str, usize) -> SerializeStructVariant);
            };
        }
    }
    #[doc(hidden)]
    pub mod size_hint {
        use crate::lib::*;
        pub fn from_bounds<I>(iter: &I) -> Option<usize> where I: Iterator {
            helper(iter.size_hint())
        }
        pub fn cautious<Element>(hint: Option<usize>) -> usize {
            const MAX_PREALLOC_BYTES: usize = 1024 * 1024;
            if mem::size_of::<Element>() == 0 {
                0
            } else {
                cmp::min(hint.unwrap_or(0),
                    MAX_PREALLOC_BYTES / mem::size_of::<Element>())
            }
        }
        fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
            match bounds {
                (lower, Some(upper)) if lower == upper => Some(upper),
                _ => None,
            }
        }
    }
    #[doc(hidden)]
    pub mod string {
        use crate::lib::*;
        #[doc(hidden)]
        pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<'_, str> {
            String::from_utf8_lossy(bytes)
        }
    }
    #[doc(hidden)]
    pub use self::content::Content;
    #[doc(hidden)]
    pub use self::seed::InPlaceSeed;
    #[doc(hidden)]
    pub use crate::lib::result::Result;
}
#[doc(hidden)]
pub mod __private {
    #[doc(hidden)]
    pub use crate::private::doc;
    #[doc(hidden)]
    pub use core::result::Result;
}crate_root!();
112
113#[macro_export]
114#[doc(hidden)]
115macro_rules! __require_serde_not_serde_core {
116    () => {
117        ::core::compile_error!(
118            "Serde derive requires a dependency on the serde crate, not serde_core"
119        );
120    };
121}
serde_core/lib.rs

serde_core/
lib.rs
