From 684548f675e08d4d8625c5a1a52ca62a386c166e Mon Sep 17 00:00:00 2001 From: github-actions Date: Sun, 30 Jun 2024 00:46:59 +0000 Subject: [PATCH] Generated docs for shadow/shadow@0ad875d --- docs/rust/either/enum.Either.html | 54 +++++++++---------- docs/rust/either/struct.IterEither.html | 2 +- docs/rust/either/trait.IntoEither.html | 2 +- docs/rust/search-index.js | 4 +- .../de/value/struct.CowStrDeserializer.html | 4 +- docs/rust/serde/de/value/struct.Error.html | 4 +- .../value/struct.MapAccessDeserializer.html | 4 +- .../de/value/struct.MapDeserializer.html | 8 +-- .../de/value/struct.StringDeserializer.html | 4 +- docs/rust/serde/ser/struct.Impossible.html | 24 ++++----- .../constant.BUILD_TIMESTAMP.html | 2 +- .../rust/type.impl/core/result/enum.Result.js | 2 +- 12 files changed, 57 insertions(+), 57 deletions(-) diff --git a/docs/rust/either/enum.Either.html b/docs/rust/either/enum.Either.html index 6f13c1a48bb..15fa693b4f9 100644 --- a/docs/rust/either/enum.Either.html +++ b/docs/rust/either/enum.Either.html @@ -455,35 +455,35 @@
§Examplesassert_eq!(other, Right(84));

Trait Implementations§

source§

impl<L, R, Target> AsMut<[Target]> for Either<L, R>
where L: AsMut<[Target]>, - R: AsMut<[Target]>,

source§

fn as_mut(&mut self) -> &mut [Target]

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R> AsMut<CStr> for Either<L, R>
where + R: AsMut<[Target]>,

source§

fn as_mut(&mut self) -> &mut [Target]

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R> AsMut<CStr> for Either<L, R>
where L: AsMut<CStr>, R: AsMut<CStr>,

Requires crate feature use_std.

source§

fn as_mut(&mut self) -> &mut CStr

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R> AsMut<OsStr> for Either<L, R>
where L: AsMut<OsStr>, R: AsMut<OsStr>,

Requires crate feature use_std.

-
source§

fn as_mut(&mut self) -> &mut OsStr

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R> AsMut<Path> for Either<L, R>
where +
source§

fn as_mut(&mut self) -> &mut OsStr

Converts this type into a mutable reference of the (usually inferred) input type.

source§

impl<L, R> AsMut<Path> for Either<L, R>
where L: AsMut<Path>, R: AsMut<Path>,

Requires crate feature use_std.

-
source§

fn as_mut(&mut self) -> &mut Path

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R, Target> AsMut<Target> for Either<L, R>
where +
source§

fn as_mut(&mut self) -> &mut Path

Converts this type into a mutable reference of the (usually inferred) input type.

source§

impl<L, R, Target> AsMut<Target> for Either<L, R>
where L: AsMut<Target>, - R: AsMut<Target>,

source§

fn as_mut(&mut self) -> &mut Target

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R> AsMut<str> for Either<L, R>
where + R: AsMut<Target>,

source§

fn as_mut(&mut self) -> &mut Target

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R> AsMut<str> for Either<L, R>
where L: AsMut<str>, - R: AsMut<str>,

source§

fn as_mut(&mut self) -> &mut str

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R, Target> AsRef<[Target]> for Either<L, R>
where + R: AsMut<str>,

source§

fn as_mut(&mut self) -> &mut str

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<L, R, Target> AsRef<[Target]> for Either<L, R>
where L: AsRef<[Target]>, R: AsRef<[Target]>,

source§

fn as_ref(&self) -> &[Target]

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<L, R> AsRef<CStr> for Either<L, R>
where L: AsRef<CStr>, R: AsRef<CStr>,

Requires crate feature use_std.

-
source§

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<L, R> AsRef<OsStr> for Either<L, R>
where +
source§

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.

source§

impl<L, R> AsRef<OsStr> for Either<L, R>
where L: AsRef<OsStr>, R: AsRef<OsStr>,

Requires crate feature use_std.

-
source§

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<L, R> AsRef<Path> for Either<L, R>
where +
source§

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.

source§

impl<L, R> AsRef<Path> for Either<L, R>
where L: AsRef<Path>, R: AsRef<Path>,

Requires crate feature use_std.

-
source§

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<L, R, Target> AsRef<Target> for Either<L, R>
where +
source§

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

source§

impl<L, R, Target> AsRef<Target> for Either<L, R>
where L: AsRef<Target>, - R: AsRef<Target>,

source§

fn as_ref(&self) -> &Target

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<L, R> AsRef<str> for Either<L, R>
where + R: AsRef<Target>,

source§

fn as_ref(&self) -> &Target

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<L, R> AsRef<str> for Either<L, R>
where L: AsRef<str>, - R: AsRef<str>,

source§

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<L, R> BufRead for Either<L, R>
where + R: AsRef<str>,

source§

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<L, R> BufRead for Either<L, R>
where L: BufRead, R: BufRead,

Requires crate feature "use_std"

source§

fn fill_buf(&mut self) -> Result<&[u8]>

Returns the contents of the internal buffer, filling it with more data @@ -492,13 +492,13 @@
§ExamplesString buffer. Read more
source§

fn has_data_left(&mut self) -> Result<bool, Error>

🔬This is a nightly-only experimental API. (buf_read_has_data_left)
Check if the underlying Read has any data left to be read. Read more
source§

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

🔬This is a nightly-only experimental API. (bufread_skip_until)
Skip all bytes until the delimiter byte or EOF is reached. Read more
1.0.0 · source§

fn split(self, byte: u8) -> Split<Self>
where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte. Read more
1.0.0 · source§

fn lines(self) -> Lines<Self>
where - Self: Sized,

Returns an iterator over the lines of this reader. Read more
source§

impl<L: Clone, R: Clone> Clone for Either<L, R>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<L: Debug, R: Debug> Debug for Either<L, R>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<L, R> Deref for Either<L, R>
where + Self: Sized,

Returns an iterator over the lines of this reader. Read more
source§

impl<L: Clone, R: Clone> Clone for Either<L, R>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<L: Debug, R: Debug> Debug for Either<L, R>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<L, R> Deref for Either<L, R>
where L: Deref, R: Deref<Target = L::Target>,

§

type Target = <L as Deref>::Target

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl<L, R> DerefMut for Either<L, R>
where L: DerefMut, R: DerefMut<Target = L::Target>,

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<L, R> Display for Either<L, R>
where L: Display, - R: Display,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<L, R> DoubleEndedIterator for Either<L, R>
where + R: Display,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<L, R> DoubleEndedIterator for Either<L, R>
where L: DoubleEndedIterator, R: DoubleEndedIterator<Item = L::Item>,

source§

fn next_back(&mut self) -> Option<Self::Item>

Removes and returns an element from the end of the iterator. Read more
source§

fn nth_back(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element from the end of the iterator. Read more
source§

fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
where G: FnMut(Acc, Self::Item) -> Acc,

An iterator method that reduces the iterator’s elements to a single, @@ -544,7 +544,7 @@
§ExamplesResult<[Self::Item; N], IntoIter<Self::Item, N>>
where Self: Sized,
🔬This is a nightly-only experimental API. (iter_next_chunk)
Advances the iterator and returns an array containing the next N values. Read more
source§

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)
Advances the iterator by n elements. Read more
1.28.0 · source§

fn step_by(self, step: usize) -> StepBy<Self>
where Self: Sized,

Creates an iterator starting at the same point, but stepping by -the given amount at each iteration. Read more
1.0.0 · source§

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
where +the given amount at each iteration. Read more

1.0.0 · source§

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence. Read more
1.0.0 · source§

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
where Self: Sized, @@ -571,7 +571,7 @@
§ExamplesFnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate. Read more
1.57.0 · source§

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps. Read more
1.0.0 · source§

fn skip(self, n: usize) -> Skip<Self>
where - Self: Sized,

Creates an iterator that skips the first n elements. Read more
1.0.0 · source§

fn take(self, n: usize) -> Take<Self>
where + Self: Sized,

Creates an iterator that skips the first n elements. Read more
1.0.0 · source§

fn take(self, n: usize) -> Take<Self>
where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner. Read more
1.0.0 · source§

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where Self: Sized, @@ -586,7 +586,7 @@
§ExamplesRead more

1.0.0 · source§

fn fuse(self) -> Fuse<Self>
where Self: Sized,

Creates an iterator which ends after the first None. Read more
1.0.0 · source§

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where Self: Sized, - F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on. Read more
1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where + F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on. Read more
1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Borrows an iterator, rather than consuming it. Read more
source§

fn collect_into<E>(self, collection: &mut E) -> &mut E
where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)
Collects all the items from an iterator into a collection. Read more
source§

fn is_partitioned<P>(self, predicate: P) -> bool
where @@ -649,7 +649,7 @@
§ExamplesSized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)
Lexicographically compares the elements of this Iterator with those -of another with respect to the specified comparison function. Read more
1.5.0 · source§

fn partial_cmp<I>(self, other: I) -> Option<Ordering>
where +of another with respect to the specified comparison function. Read more

1.5.0 · source§

fn partial_cmp<I>(self, other: I) -> Option<Ordering>
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of @@ -671,19 +671,19 @@
§ExamplesIntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,
Determines if the elements of this Iterator are not equal to those of -another. Read more
1.5.0 · source§

fn lt<I>(self, other: I) -> bool
where +another. Read more

1.5.0 · source§

fn lt<I>(self, other: I) -> bool
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically -less than those of another. Read more
1.5.0 · source§

fn le<I>(self, other: I) -> bool
where +less than those of another. Read more

1.5.0 · source§

fn le<I>(self, other: I) -> bool
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically -less or equal to those of another. Read more
1.5.0 · source§

fn gt<I>(self, other: I) -> bool
where +less or equal to those of another. Read more

1.5.0 · source§

fn gt<I>(self, other: I) -> bool
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically -greater than those of another. Read more
1.5.0 · source§

fn ge<I>(self, other: I) -> bool
where +greater than those of another. Read more

1.5.0 · source§

fn ge<I>(self, other: I) -> bool
where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically @@ -698,19 +698,19 @@
§ExamplesSized,
Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl<L: PartialEq, R: PartialEq> PartialEq for Either<L, R>

source§

fn eq(&self, other: &Either<L, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl<L: PartialOrd, R: PartialOrd> PartialOrd for Either<L, R>

source§

fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= -operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= +sufficient, and should not be overridden without very good reason.
source§

impl<L: PartialOrd, R: PartialOrd> PartialOrd for Either<L, R>

source§

fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= +operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl<L, R> Read for Either<L, R>
where L: Read, R: Read,

Either<L, R> implements Read if both L and R do.

Requires crate feature "use_std"

source§

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more
source§

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

Read the exact number of bytes required to fill buf. Read more
source§

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Read all bytes until EOF in this source, placing them into buf. Read more
source§

fn read_to_string(&mut self, buf: &mut String) -> Result<usize>

Read all bytes until EOF in this source, appending them to buf. Read more
1.36.0 · source§

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers. Read more
source§

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)
Determines if this Reader has an efficient read_vectored -implementation. Read more
source§

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)
Pull some bytes from this source into the specified buffer. Read more
source§

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)
Read the exact number of bytes required to fill cursor. Read more
1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where +implementation. Read more

source§

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)
Pull some bytes from this source into the specified buffer. Read more
source§

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)
Read the exact number of bytes required to fill cursor. Read more
1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Creates a “by reference” adaptor for this instance of Read. Read more
1.0.0 · source§

fn bytes(self) -> Bytes<Self>
where - Self: Sized,

Transforms this Read instance to an Iterator over its bytes. Read more
1.0.0 · source§

fn chain<R>(self, next: R) -> Chain<Self, R>
where + Self: Sized,

Transforms this Read instance to an Iterator over its bytes. Read more
1.0.0 · source§

fn chain<R>(self, next: R) -> Chain<Self, R>
where R: Read, - Self: Sized,

Creates an adapter which will chain this stream with another. Read more
1.0.0 · source§

fn take(self, limit: u64) -> Take<Self>
where + Self: Sized,

Creates an adapter which will chain this stream with another. Read more
1.0.0 · source§

fn take(self, limit: u64) -> Take<Self>
where Self: Sized,

Creates an adapter which will read at most limit bytes from it. Read more
source§

impl<L, R> Seek for Either<L, R>
where L: Seek, R: Seek,

Either<L, R> implements Seek if both L and R do.

@@ -722,7 +722,7 @@
§Examples
source§

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written. Read more
source§

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer. Read more
source§

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>

Writes a formatted string into this writer, returning any error encountered. Read more
source§

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more
1.36.0 · source§

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers. Read more
source§

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)
Determines if this Writer has an efficient write_vectored -implementation. Read more
source§

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)
Attempts to write multiple buffers into this writer. Read more
1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where +implementation. Read more

source§

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)
Attempts to write multiple buffers into this writer. Read more
1.0.0 · source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Creates a “by reference” adapter for this instance of Write. Read more
source§

impl<L: Copy, R: Copy> Copy for Either<L, R>

source§

impl<L: Eq, R: Eq> Eq for Either<L, R>

source§

impl<L, R> FusedIterator for Either<L, R>
where L: FusedIterator, R: FusedIterator<Item = L::Item>,

source§

impl<L, R> StructuralPartialEq for Either<L, R>

Auto Trait Implementations§

§

impl<L, R> Freeze for Either<L, R>
where @@ -758,4 +758,4 @@
§ExamplesClone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
\ No newline at end of file + U: TryFrom<T>,
§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
\ No newline at end of file diff --git a/docs/rust/either/struct.IterEither.html b/docs/rust/either/struct.IterEither.html index b1ce7e5dd1a..ae49d05bfe2 100644 --- a/docs/rust/either/struct.IterEither.html +++ b/docs/rust/either/struct.IterEither.html @@ -214,4 +214,4 @@ I: Iterator,
§

type Item = <I as Iterator>::Item

The type of the elements being iterated over.
§

type IntoIter = I

Which kind of iterator are we turning this into?
const: unstable · source§

fn into_iter(self) -> I

Creates an iterator from a value. Read more
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
\ No newline at end of file + U: TryFrom<T>,
§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
\ No newline at end of file diff --git a/docs/rust/either/trait.IntoEither.html b/docs/rust/either/trait.IntoEither.html index 2d28600f8e1..6d7f074c63c 100644 --- a/docs/rust/either/trait.IntoEither.html +++ b/docs/rust/either/trait.IntoEither.html @@ -34,4 +34,4 @@
§Examples
let x = 0; assert_eq!(x.into_either_with(is_even), Left(x)); assert_eq!(x.into_either_with(|x| !is_even(x)), Right(x)); -

Object Safety§

This trait is not object safe.

Implementors§

source§

impl<T> IntoEither for T

\ No newline at end of file +

Object Safety§

This trait is not object safe.

Implementors§

source§

impl<T> IntoEither for T

\ No newline at end of file diff --git a/docs/rust/search-index.js b/docs/rust/search-index.js index 966a10fccd0..c9951ee13fb 100644 --- a/docs/rust/search-index.js +++ b/docs/rust/search-index.js @@ -30,7 +30,7 @@ var searchIndex = new Map(JSON.parse('[\ ["crossbeam_queue",{"t":"FFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["ArrayQueue","SegQueue","borrow","borrow","borrow_mut","borrow_mut","capacity","default","drop","drop","fmt","fmt","force_push","from","from","into","into","into_iter","into_iter","is_empty","is_empty","is_full","len","len","new","new","pop","pop","push","push","try_from","try_from","try_into","try_into","type_id","type_id"],"q":[[0,"crossbeam_queue"],[36,"crossbeam_queue::array_queue"],[37,"crossbeam_queue::seg_queue"],[38,"core::fmt"],[39,"core::option"],[40,"core::result"],[41,"core::any"]],"i":[0,0,1,3,1,3,1,3,1,3,1,3,1,1,3,1,3,1,3,1,3,1,1,3,1,3,1,3,1,3,1,3,1,3,1,3],"f":"``{ce{}{}}000{{{b{c}}}d{}}{{}{{f{c}}}{}}{{{b{c}}}h{}}{{{f{c}}}h{}}{{{b{c}}j}l{}}{{{f{c}}j}l{}}{{{b{c}}c}{{n{c}}}{}}{cc{}}088{{{b{c}}}e{}{}}{{{f{c}}}e{}{}}{{{b{c}}}A`{}}{{{f{c}}}A`{}}1;{{{f{c}}}d{}}{d{{b{c}}}{}}<{{{b{c}}}{{n{c}}}{}}{{{f{c}}}{{n{c}}}{}}{{{b{c}}c}{{Ab{hc}}}{}}{{{f{c}}c}h{}}{c{{Ab{e}}}{}{}}000{cAd{}}0","D":"Bh","p":[[5,"ArrayQueue",0,36],[1,"usize"],[5,"SegQueue",0,37],[1,"unit"],[5,"Formatter",38],[8,"Result",38],[6,"Option",39],[1,"bool"],[6,"Result",40],[5,"TypeId",41]],"r":[[0,36],[1,37]],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAABAABAADAAMACAAEABIAAQAfAAUA"}],\ ["crossbeam_utils",{"t":"FFCNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCNNNNNNNNFKRNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNN","n":["Backoff","CachePadded","atomic","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","default","default","deref","deref_mut","eq","fmt","fmt","fmt","from","from","from","from","hash","into","into","into_inner","is_completed","new","new","reset","snooze","spin","sync","thread","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","AtomicCell","AtomicConsume","Val","as_ptr","borrow","borrow_mut","compare_and_swap","compare_exchange","default","drop","fetch_add","fetch_add","fetch_add","fetch_add","fetch_add","fetch_add","fetch_add","fetch_add","fetch_add","fetch_add","fetch_add","fetch_add","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_and","fetch_max","fetch_max","fetch_max","fetch_max","fetch_max","fetch_max","fetch_max","fetch_max","fetch_max","fetch_max","fetch_max","fetch_max","fetch_min","fetch_min","fetch_min","fetch_min","fetch_min","fetch_min","fetch_min","fetch_min","fetch_min","fetch_min","fetch_min","fetch_min","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_nand","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_or","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_sub","fetch_update","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fetch_xor","fmt","from","from","from","into","into_inner","is_lock_free","load","load_consume","new","store","swap","take","try_from","try_into","type_id","Parker","ShardedLock","ShardedLockReadGuard","ShardedLockWriteGuard","Unparker","WaitGroup","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","default","default","default","deref","deref","deref_mut","drop","drop","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from_raw","from_raw","get_mut","into","into","into","into","into","into","into_inner","into_raw","into_raw","is_poisoned","new","new","new","park","park_deadline","park_timeout","read","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_read","try_write","type_id","type_id","type_id","type_id","type_id","type_id","unpark","unparker","wait","write","Scope","ScopedJoinHandle","ScopedThreadBuilder","as_pthread_t","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","builder","fmt","fmt","fmt","from","from","from","into","into","into","into_pthread_t","join","name","scope","spawn","spawn","stack_size","thread","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id"],"q":[[0,"crossbeam_utils"],[41,"crossbeam_utils::atomic"],[168,"crossbeam_utils::sync"],[262,"crossbeam_utils::thread"],[299,"crossbeam_utils::cache_padded"],[300,"core::clone"],[301,"crossbeam_utils::backoff"],[302,"core::default"],[303,"core::cmp"],[304,"core::fmt"],[305,"core::hash"],[306,"alloc::string"],[307,"core::result"],[308,"core::any"],[309,"crossbeam_utils::atomic::atomic_cell"],[310,"core::marker"],[311,"core::option"],[312,"core::ops::function"],[313,"crossbeam_utils::atomic::consume"],[314,"crossbeam_utils::sync::parker"],[315,"crossbeam_utils::sync::wait_group"],[316,"crossbeam_utils::sync::sharded_lock"],[317,"std::sync::poison"],[318,"std::time"],[319,"core::time"],[320,"std::os::unix::thread"],[321,"std::thread"],[322,"std::io::error"]],"i":[0,0,0,4,1,4,1,1,1,4,1,1,1,1,4,1,1,4,1,1,1,1,4,1,1,4,4,1,4,4,4,0,0,1,1,4,1,4,1,4,1,0,0,37,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,37,18,18,18,18,18,18,18,0,0,0,0,0,0,40,38,41,39,42,44,40,38,41,39,42,44,38,39,38,39,40,41,39,42,44,44,39,44,40,38,41,39,42,42,44,44,40,38,41,41,41,39,42,44,40,38,41,40,38,41,39,42,44,41,40,38,41,40,41,39,40,40,40,41,38,39,42,44,40,38,41,39,42,44,40,38,41,39,42,44,41,41,40,38,41,39,42,44,38,40,39,41,0,0,0,49,51,49,52,51,49,52,51,51,49,52,51,49,52,51,49,52,49,49,52,0,51,52,52,49,51,49,52,51,49,52,51,49,52],"f":"```{ce{}{}}000{{{b{c}}}{{b{c}}}d}{{ce}f{}{}}{{}h}{{}{{b{c}}}j}{{{b{c}}}c{}}0{{{b{c}}{b{c}}}ln}{{hA`}Ab}{{{b{c}}A`}AbAd}{{{b{c}}A`}AbAf}{cc{}}{Ahc{}}{c{{b{c}}}{}}2{{{b{c}}e}fAjAl}==8{hl};2{hf}00``?{cAn{}}{c{{B`{e}}}{}{}}000{cBb{}}0```{{{Bd{c}}}{}{}}{ce{}{}}0{{{Bd{c}}cc}c{BfBh}}{{{Bd{c}}cc}{{B`{cc}}}{BfBh}}{{}{{Bd{c}}}j}{{{Bd{c}}}f{}}{{{Bd{Bj}}Bj}Bj}{{{Bd{Bl}}Bl}Bl}{{{Bd{Bn}}Bn}Bn}{{{Bd{C`}}C`}C`}{{{Bd{Cb}}Cb}Cb}{{{Bd{Cd}}Cd}Cd}{{{Bd{Cf}}Cf}Cf}{{{Bd{Ch}}Ch}Ch}{{{Bd{Cj}}Cj}Cj}{{{Bd{Cl}}Cl}Cl}{{{Bd{Cn}}Cn}Cn}{{{Bd{D`}}D`}D`}:9{{{Bd{l}}l}l}435198276<761<:9834;25:;8476152<9365:328<041;795620741<;93:835768;4<912:{{{Bd{c}}e}{{B`{cc}}}{BfBh}{{Df{c}{{Db{{Dd{c}}}}}}}}732;1564<8=:9{{{Bd{c}}A`}Ab{BfAd}}{c{{Bd{c}}}{}}{Ahc{}}{cc{}}{ce{}{}}{{{Bd{c}}}c{}}{{}l}{{{Bd{c}}}cBf}{{{Dj{}{{Dh{c}}}}}c{}}7{{{Bd{c}}c}f{}}{{{Bd{c}}c}c{}}{{{Bd{c}}}cj}{c{{B`{e}}}{}{}}0{cBb{}}``````999999999999{DlDl}{DnDn}{{ce}f{}{}}0{{}E`}{{}{{Eb{c}}}j}{{}Dn}{{{Ed{c}}}cEf}{{{Eh{c}}}cEf}0{Dnf}{{{Eh{c}}}fEf}{{E`A`}Ab}{{DlA`}Ab}{{{Eb{c}}A`}Ab{EfAd}}{{DnA`}Ab}{{{Ed{c}}A`}AbAd}{{{Ed{c}}A`}Ab{EfAf}}{{{Eh{c}}A`}AbAd}{{{Eh{c}}A`}Ab{EfAf}}{cc{}}00{c{{Eb{c}}}{}}{Ahc{}}222{fE`}{fDl}{{{Eb{c}}}{{Ej{c}}}Ef}{ce{}{}}00000{{{Eb{c}}}{{Ej{c}}}{}}{E`f}{Dlf}{{{Eb{c}}}lEf}{{}E`}:{{}Dn}4{{E`El}f}{{E`En}f}{{{Eb{c}}}{{Ej{{Ed{c}}}}}Ef}99{cAn{}}0{c{{B`{e}}}{}{}}00000000000{{{Eb{c}}}{{F`{{Ed{c}}}}}Ef}{{{Eb{c}}}{{F`{{Eh{c}}}}}Ef}{cBb{}}00000;{E`Dl}{Dnf}{{{Eb{c}}}{{Ej{{Eh{c}}}}}Ef}```{{{Fb{c}}}Fd{}}{ce{}{}}00000{FfFh}{{FfA`}Ab}{{{Fb{c}}A`}Ab{}}{{FhA`}Ab}{cc{}}005556{{{Fb{c}}}{{Fj{c}}}{}}{{FhAn}Fh}{e{{Fj{c}}}{}{{Fl{Ff}{{Db{c}}}}}}{{Ffe}{{Fb{c}}}Fn{{Fl{Ff}{{Db{c}}}}Fn}}{{Fhe}{{G`{{Fb{c}}}}}Fn{{Fl{Ff}{{Db{c}}}}Fn}}{{FhCb}Fh}{{{Fb{c}}}Gb{}}{c{{B`{e}}}{}{}}00000{cBb{}}00","D":"AGj","p":[[5,"CachePadded",0,299],[10,"Clone",300],[1,"unit"],[5,"Backoff",0,301],[10,"Default",302],[1,"bool"],[10,"PartialEq",303],[5,"Formatter",304],[8,"Result",304],[10,"Debug",304],[10,"Display",304],[1,"never"],[10,"Hash",305],[10,"Hasher",305],[5,"String",306],[6,"Result",307],[5,"TypeId",308],[5,"AtomicCell",41,309],[10,"Copy",310],[10,"Eq",303],[1,"u32"],[1,"u64"],[1,"u8"],[1,"i128"],[1,"usize"],[1,"i32"],[1,"u128"],[1,"i8"],[1,"i16"],[1,"i64"],[1,"u16"],[1,"isize"],[17,"Output"],[6,"Option",311],[10,"FnMut",312],[17,"Val"],[10,"AtomicConsume",41,313],[5,"Unparker",168,314],[5,"WaitGroup",168,315],[5,"Parker",168,314],[5,"ShardedLock",168,316],[5,"ShardedLockReadGuard",168,316],[10,"Sized",310],[5,"ShardedLockWriteGuard",168,316],[8,"LockResult",317],[5,"Instant",318],[5,"Duration",319],[8,"TryLockResult",317],[5,"ScopedJoinHandle",262],[8,"RawPthread",320],[5,"Scope",262],[5,"ScopedThreadBuilder",262],[8,"Result",321],[10,"FnOnce",312],[10,"Send",310],[8,"Result",322],[5,"Thread",321]],"r":[[0,301],[1,299],[41,309],[42,313],[168,314],[169,316],[170,316],[171,316],[172,314],[173,315]],"b":[[15,"impl-Debug-for-CachePadded%3CT%3E"],[16,"impl-Display-for-CachePadded%3CT%3E"],[51,"impl-AtomicCell%3Cu32%3E"],[52,"impl-AtomicCell%3Cu64%3E"],[53,"impl-AtomicCell%3Cu8%3E"],[54,"impl-AtomicCell%3Ci128%3E"],[55,"impl-AtomicCell%3Cusize%3E"],[56,"impl-AtomicCell%3Ci32%3E"],[57,"impl-AtomicCell%3Cu128%3E"],[58,"impl-AtomicCell%3Ci8%3E"],[59,"impl-AtomicCell%3Ci16%3E"],[60,"impl-AtomicCell%3Ci64%3E"],[61,"impl-AtomicCell%3Cu16%3E"],[62,"impl-AtomicCell%3Cisize%3E"],[63,"impl-AtomicCell%3Cu64%3E"],[64,"impl-AtomicCell%3Cu8%3E"],[65,"impl-AtomicCell%3Cbool%3E"],[66,"impl-AtomicCell%3Ci16%3E"],[67,"impl-AtomicCell%3Ci64%3E"],[68,"impl-AtomicCell%3Ci8%3E"],[69,"impl-AtomicCell%3Cisize%3E"],[70,"impl-AtomicCell%3Ci128%3E"],[71,"impl-AtomicCell%3Cusize%3E"],[72,"impl-AtomicCell%3Cu16%3E"],[73,"impl-AtomicCell%3Ci32%3E"],[74,"impl-AtomicCell%3Cu128%3E"],[75,"impl-AtomicCell%3Cu32%3E"],[76,"impl-AtomicCell%3Ci32%3E"],[77,"impl-AtomicCell%3Cu128%3E"],[78,"impl-AtomicCell%3Cisize%3E"],[79,"impl-AtomicCell%3Cu32%3E"],[80,"impl-AtomicCell%3Cu8%3E"],[81,"impl-AtomicCell%3Ci128%3E"],[82,"impl-AtomicCell%3Cusize%3E"],[83,"impl-AtomicCell%3Ci64%3E"],[84,"impl-AtomicCell%3Ci16%3E"],[85,"impl-AtomicCell%3Cu64%3E"],[86,"impl-AtomicCell%3Cu16%3E"],[87,"impl-AtomicCell%3Ci8%3E"],[88,"impl-AtomicCell%3Cu8%3E"],[89,"impl-AtomicCell%3Cu64%3E"],[90,"impl-AtomicCell%3Cusize%3E"],[91,"impl-AtomicCell%3Ci16%3E"],[92,"impl-AtomicCell%3Ci32%3E"],[93,"impl-AtomicCell%3Cu128%3E"],[94,"impl-AtomicCell%3Cisize%3E"],[95,"impl-AtomicCell%3Ci8%3E"],[96,"impl-AtomicCell%3Cu16%3E"],[97,"impl-AtomicCell%3Cu32%3E"],[98,"impl-AtomicCell%3Ci128%3E"],[99,"impl-AtomicCell%3Ci64%3E"],[100,"impl-AtomicCell%3Cu128%3E"],[101,"impl-AtomicCell%3Ci8%3E"],[102,"impl-AtomicCell%3Cu8%3E"],[103,"impl-AtomicCell%3Ci64%3E"],[104,"impl-AtomicCell%3Cu16%3E"],[105,"impl-AtomicCell%3Cusize%3E"],[106,"impl-AtomicCell%3Cu32%3E"],[107,"impl-AtomicCell%3Cbool%3E"],[108,"impl-AtomicCell%3Ci16%3E"],[109,"impl-AtomicCell%3Cisize%3E"],[110,"impl-AtomicCell%3Cu64%3E"],[111,"impl-AtomicCell%3Ci32%3E"],[112,"impl-AtomicCell%3Ci128%3E"],[113,"impl-AtomicCell%3Ci8%3E"],[114,"impl-AtomicCell%3Cu128%3E"],[115,"impl-AtomicCell%3Cu16%3E"],[116,"impl-AtomicCell%3Cbool%3E"],[117,"impl-AtomicCell%3Ci32%3E"],[118,"impl-AtomicCell%3Ci16%3E"],[119,"impl-AtomicCell%3Cisize%3E"],[120,"impl-AtomicCell%3Cu32%3E"],[121,"impl-AtomicCell%3Cu64%3E"],[122,"impl-AtomicCell%3Ci128%3E"],[123,"impl-AtomicCell%3Ci64%3E"],[124,"impl-AtomicCell%3Cu8%3E"],[125,"impl-AtomicCell%3Cusize%3E"],[126,"impl-AtomicCell%3Ci64%3E"],[127,"impl-AtomicCell%3Ci8%3E"],[128,"impl-AtomicCell%3Ci32%3E"],[129,"impl-AtomicCell%3Cu128%3E"],[130,"impl-AtomicCell%3Cusize%3E"],[131,"impl-AtomicCell%3Cu64%3E"],[132,"impl-AtomicCell%3Ci16%3E"],[133,"impl-AtomicCell%3Cu32%3E"],[134,"impl-AtomicCell%3Ci128%3E"],[135,"impl-AtomicCell%3Cisize%3E"],[136,"impl-AtomicCell%3Cu16%3E"],[137,"impl-AtomicCell%3Cu8%3E"],[139,"impl-AtomicCell%3Cu128%3E"],[140,"impl-AtomicCell%3Cu16%3E"],[141,"impl-AtomicCell%3Cisize%3E"],[142,"impl-AtomicCell%3Cu8%3E"],[143,"impl-AtomicCell%3Cbool%3E"],[144,"impl-AtomicCell%3Ci16%3E"],[145,"impl-AtomicCell%3Ci8%3E"],[146,"impl-AtomicCell%3Ci64%3E"],[147,"impl-AtomicCell%3Cu64%3E"],[148,"impl-AtomicCell%3Ci32%3E"],[149,"impl-AtomicCell%3Cu32%3E"],[150,"impl-AtomicCell%3Ci128%3E"],[151,"impl-AtomicCell%3Cusize%3E"],[202,"impl-Debug-for-ShardedLockReadGuard%3C\'_,+T%3E"],[203,"impl-Display-for-ShardedLockReadGuard%3C\'_,+T%3E"],[204,"impl-Debug-for-ShardedLockWriteGuard%3C\'_,+T%3E"],[205,"impl-Display-for-ShardedLockWriteGuard%3C\'_,+T%3E"]],"c":"OjAAAAEAAAAAAAAAEAAAADAA","e":"OzAAAAEAAG4AEAAEAA0AEwABABYAAAAiAAcALgABADIAAQCZAAIApgACAK8AHwDSAAEA6wAPAP0ABQAKAQYAEgECABsBAAAjAQgA"}],\ ["dyn_clone",{"t":"KHHHQH","n":["DynClone","arc_make_mut","clone","clone_box","clone_trait_object","rc_make_mut"],"q":[[0,"dyn_clone"],[6,"alloc::sync"],[7,"core::marker"],[8,"alloc::boxed"],[9,"alloc::rc"]],"i":[0,0,0,0,0,0],"f":"`{{{b{c}}}c{df}}{ccf}{c{{h{c}}}{df}}`{{{j{c}}}c{df}}","D":"n","p":[[5,"Arc",6],[10,"Sized",7],[10,"DynClone",0],[5,"Box",8],[5,"Rc",9]],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAAAAAA="}],\ -["either",{"t":"GKFEPEPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQQNNNNNNN","n":["Either","IntoEither","IterEither","Left","Left","Right","Right","all","all","any","any","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_pin_mut","as_pin_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","borrow","borrow","borrow_mut","borrow_mut","cause","clone","clone","clone_from","clone_into","clone_into","cmp","collect","collect","consume","count","count","deref","deref_mut","description","either","either_into","either_with","eq","expect_left","expect_right","extend","factor_err","factor_first","factor_into_iter","factor_iter","factor_iter_mut","factor_none","factor_ok","factor_second","fill_buf","find","find","find_map","find_map","flip","flush","fmt","fmt","fmt","fold","fold","for_both","for_each","for_each","from","from","from","hash","into","into","into","into_either","into_either","into_either_with","into_either_with","into_future","into_inner","into_iter","into_iter","into_iter","is_left","is_right","iter","iter_mut","last","last","left","left_and_then","left_or","left_or_default","left_or_else","len","len","map","map_either","map_either_with","map_left","map_right","next","next","next_back","next_back","nth","nth","nth_back","nth_back","partial_cmp","partition","partition","poll","position","position","read","read_exact","read_line","read_to_end","read_to_string","read_until","rfind","rfind","rfold","rfold","right","right_and_then","right_or","right_or_default","right_or_else","seek","size_hint","size_hint","source","to_owned","to_owned","to_string","try_from","try_from","try_into","try_into","try_left","try_right","type_id","type_id","unwrap_left","unwrap_right","write","write_all","write_fmt"],"q":[[0,"either"],[159,"core::iter::traits::iterator"],[160,"core::ops::function"],[161,"either::iterator"],[162,"core::ffi::c_str"],[163,"core::convert"],[164,"std::ffi::os_str"],[165,"std::path"],[166,"core::pin"],[167,"core::error"],[168,"core::option"],[169,"core::clone"],[170,"core::cmp"],[171,"core::iter::traits::collect"],[172,"std::io"],[173,"core::ops::deref"],[174,"core::fmt"],[175,"core::result"],[176,"std::io::error"],[177,"core::hash"],[178,"either::into_either"],[179,"core::default"],[180,"core::iter::traits::exact_size"],[181,"core::iter::traits::double_ended"],[182,"core::task::wake"],[183,"core::task::poll"],[184,"core::future::future"],[185,"alloc::string"],[186,"alloc::vec"],[187,"core::any"]],"i":[0,0,0,0,1,0,1,1,7,1,7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,7,1,7,1,1,7,1,1,7,1,1,7,1,1,7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,7,1,7,1,1,1,1,7,1,7,0,1,7,1,1,7,1,1,1,7,44,44,44,44,1,1,1,1,7,1,1,1,1,1,7,1,1,1,1,1,1,7,1,1,1,1,1,1,7,1,7,1,7,1,7,1,1,7,1,1,7,1,1,1,1,1,1,1,7,1,7,1,1,1,1,1,1,1,7,1,1,7,1,1,7,1,7,0,0,1,7,1,1,1,1,1],"f":"```````{{{b{ce}}i}df{{f{}{{h{}}}}}{}{{l{g}{{j{d}}}}}}{{{n{ce}}i}dff{}{{l{g}{{j{d}}}}}}10{{{b{ce}}}A`{{Ab{A`}}}{{Ab{A`}}}}{{{b{ce}}}Ad{{Ab{Ad}}}{{Ab{Ad}}}}{{{b{ce}}}Af{{Ab{Af}}}{{Ab{Af}}}}{{{b{ce}}}{{b{ce}}}{}{}}{{{b{ce}}}Ah{{Ab{Ah}}}{{Ab{Ah}}}}{{{b{eg}}}{{Aj{c}}}{}{{Ab{{Aj{c}}}}}{{Ab{{Aj{c}}}}}}{{{b{eg}}}c{}{{Ab{c}}}{{Ab{c}}}}{{{Al{{b{ce}}}}}{{b{{Al{c}}{Al{e}}}}}{}{}}0{{{b{eg}}}{{Aj{c}}}{}{{An{{Aj{c}}}}}{{An{{Aj{c}}}}}}{{{b{ce}}}A`{{An{A`}}}{{An{A`}}}}{{{b{ce}}}Af{{An{Af}}}{{An{Af}}}}{{{b{eg}}}c{}{{An{c}}}{{An{c}}}}8{{{b{ce}}}Ah{{An{Ah}}}{{An{Ah}}}}{{{b{ce}}}Ad{{An{Ad}}}{{An{Ad}}}}{ce{}{}}000{{{b{ce}}}{{Bb{B`}}}B`B`}{{{b{ce}}}{{b{ce}}}BdBd}{{{n{ce}}}{{n{ce}}}BdBd}{{{b{ce}}{b{ce}}}BfBdBd}{{ce}Bf{}{}}0{{{b{ce}}{b{ce}}}BhBjBj}{{{b{ce}}}if{{f{}{{h{}}}}}{}{{Bl{g}}}}{{{n{ce}}}iff{}{{Bl{g}}}}{{{b{ce}}Bn}BfC`C`}{{{b{ce}}}Bnf{{f{}{{h{}}}}}}{{{n{ce}}}Bnff}{{{b{ce}}}gCb{{Cb{}{{Cd{}}}}}{}}{{{b{ce}}}gCf{{Cf{}{{Cd{}}}}}{}}{{{b{ce}}}AfB`B`}{{{b{ce}}ik}g{}{}{}{{Ch{c}{{j{g}}}}}{{Ch{e}{{j{g}}}}}}{{{b{eg}}}c{}{{Cj{c}}}{{Cj{c}}}}{{{b{ce}}gkm}i{}{}{}{}{{Ch{gc}{{j{i}}}}}{{Ch{ge}{{j{i}}}}}}{{{b{ce}}{b{ce}}}dClCl}{{{b{ce}}Af}c{}Cn}{{{b{ce}}Af}eCn{}}{{{b{eg}}i}Bf{}{{D`{c}}}{{D`{c}}}{{Db{}{{h{c}}}}}}{{{b{{Dd{ce}}{Dd{ge}}}}}{{Dd{{b{cg}}e}}}{}{}{}}{{{b{{Df{ce}}{Df{cg}}}}}{{Df{c{b{eg}}}}}{}{}{}}{{{b{ce}}}nDbDb}{{{b{ce}}}n{}{}}0{{{b{{Bb{c}}{Bb{e}}}}}{{Bb{{b{ce}}}}}{}{}}{{{b{{Dd{ce}}{Dd{cg}}}}}{{Dd{c{b{eg}}}}}{}{}{}}{{{b{{Df{ce}}{Df{ge}}}}}{{Df{{b{cg}}e}}}{}{}{}}{{{b{ce}}}{{Dj{{Aj{Dh}}}}}C`C`}{{{b{ce}}i}{{Bb{g}}}f{{f{}{{h{}}}}}{}{{l{g}{{j{d}}}}}}{{{n{ce}}i}{{Bb{g}}}ff{}{{l{g}{{j{d}}}}}}{{{b{ce}}k}{{Bb{i}}}f{{f{}{{h{}}}}}{}{}{{l{g}{{j{{Bb{i}}}}}}}}{{{n{ce}}k}{{Bb{i}}}ff{}{}{{l{g}{{j{{Bb{i}}}}}}}}{{{b{ce}}}{{b{ec}}}{}{}}{{{b{ce}}}{{Dj{Bf}}}DlDl}{{{b{ce}}Dn}E`EbEb}{{{b{ce}}Dn}E`CnCn}{{{n{ce}}Dn}E`CnCn}{{{b{ce}}gk}gf{{f{}{{h{}}}}}{}{}{{l{gi}{{j{g}}}}}}{{{n{ce}}gk}gff{}{}{{l{gi}{{j{g}}}}}}`{{{b{ce}}i}Bff{{f{}{{h{}}}}}{}{{l{g}}}}{{{n{ce}}i}Bfff{}{{l{g}}}}{{{Dd{ce}}}{{b{ec}}}{}{}}{cc{}}0{{{b{ce}}g}BfEdEdEf}{{{b{ce}}}{{Dd{ec}}}{}{}}{ce{}{}}0{{Ehd}{{b{EhEh}}}}0{{Ehc}{{b{EhEh}}}{{Ch{Eh}{{j{d}}}}}}0{c{}{}}{{{b{cc}}}c{}}{{{b{ce}}}bDb{{Db{}{{h{}}}}}}55{{{b{ce}}}d{}{}}0{{{b{ce}}}b{}{}}0{{{b{ce}}}{{Bb{g}}}f{{f{}{{h{}}}}}{}}{{{n{ce}}}{{Bb{g}}}ff{}}{{{b{ce}}}{{Bb{c}}}{}{}}{{{b{ce}}i}{{b{ge}}}{}{}{}{{Ch{c}{{j{{b{ge}}}}}}}}{{{b{ce}}c}c{}{}}{{{b{ce}}}cEj{}}{{{b{ce}}g}c{}{}{{Ch{e}{{j{c}}}}}}{{{b{ce}}}BnEl{{El{}{{h{}}}}}}{{{n{ce}}}BnElEl}{{{b{cc}}g}{{b{ee}}}{}{}{{Ch{c}{{j{e}}}}}}{{{b{ce}}im}{{b{gk}}}{}{}{}{{Ch{c}{{j{g}}}}}{}{{Ch{e}{{j{k}}}}}}{{{b{ce}}gko}{{b{im}}}{}{}{}{}{{Ch{gc}{{j{i}}}}}{}{{Ch{ge}{{j{m}}}}}}{{{b{ce}}i}{{b{ge}}}{}{}{}{{Ch{c}{{j{g}}}}}}{{{b{ce}}i}{{b{cg}}}{}{}{}{{Ch{e}{{j{g}}}}}}=<{{{b{ce}}}{{Bb{g}}}En{{En{}{{h{}}}}}{}}{{{n{ce}}}{{Bb{g}}}EnEn{}}{{{b{ce}}Bn}{{Bb{g}}}f{{f{}{{h{}}}}}{}}{{{n{ce}}Bn}{{Bb{g}}}ff{}}{{{b{ce}}Bn}{{Bb{g}}}En{{En{}{{h{}}}}}{}}{{{n{ce}}Bn}{{Bb{g}}}EnEn{}}{{{b{ce}}{b{ce}}}{{Bb{Bh}}}F`F`}{{{b{ce}}i}{{Df{kk}}}f{{f{}{{h{}}}}}{}{{l{g}{{j{d}}}}}{Ej{D`{g}}}}{{{n{ce}}i}{{Df{kk}}}ff{}{{l{g}{{j{d}}}}}{Ej{D`{g}}}}{{{Al{{b{ce}}}}Fb}{{Fd{g}}}Ff{{Ff{}{{j{}}}}}{}}{{{b{ce}}i}{{Bb{Bn}}}f{{f{}{{h{}}}}}{}{{l{g}{{j{d}}}}}}{{{n{ce}}i}{{Bb{Bn}}}ff{}{{l{g}{{j{d}}}}}}{{{b{ce}}{Aj{Dh}}}{{Dj{Bn}}}FhFh}{{{b{ce}}{Aj{Dh}}}{{Dj{Bf}}}FhFh}{{{b{ce}}Fj}{{Dj{Bn}}}C`C`}{{{b{ce}}{Fl{Dh}}}{{Dj{Bn}}}FhFh}{{{b{ce}}Fj}{{Dj{Bn}}}FhFh}{{{b{ce}}Dh{Fl{Dh}}}{{Dj{Bn}}}C`C`}{{{b{ce}}i}{{Bb{g}}}En{{En{}{{h{}}}}}{}{{l{g}{{j{d}}}}}}{{{n{ce}}i}{{Bb{g}}}EnEn{}{{l{g}{{j{d}}}}}}{{{b{ce}}gk}gEn{{En{}{{h{}}}}}{}{}{{l{gi}{{j{g}}}}}}{{{n{ce}}gk}gEnEn{}{}{{l{gi}{{j{g}}}}}}{{{b{ce}}}{{Bb{e}}}{}{}}{{{b{ce}}i}{{b{cg}}}{}{}{}{{Ch{e}{{j{{b{cg}}}}}}}}{{{b{ce}}e}e{}{}}{{{b{ce}}}e{}Ej}{{{b{ce}}g}e{}{}{{Ch{c}{{j{e}}}}}}{{{b{ce}}Fn}{{Dj{G`}}}GbGb}{{{b{ce}}}{{Df{Bn{Bb{Bn}}}}}f{{f{}{{h{}}}}}}{{{n{ce}}}{{Df{Bn{Bb{Bn}}}}}ff}{{{b{ce}}}{{Bb{B`}}}B`B`}{ce{}{}}0{cFj{}}{c{{Dd{e}}}{}{}}000``{cGd{}}0{{{b{ce}}}c{}Cn}{{{b{ce}}}eCn{}}{{{b{ce}}{Aj{Dh}}}{{Dj{Bn}}}DlDl}{{{b{ce}}{Aj{Dh}}}{{Dj{Bf}}}DlDl}{{{b{ce}}Gf}{{Dj{Bf}}}DlDl}","D":"Gd","p":[[6,"Either",0],[1,"bool"],[10,"Iterator",159],[17,"Item"],[17,"Output"],[10,"FnMut",160],[5,"IterEither",0,161],[5,"CStr",162],[10,"AsMut",163],[5,"OsStr",164],[1,"str"],[5,"Path",165],[1,"slice"],[5,"Pin",166],[10,"AsRef",163],[10,"Error",167],[6,"Option",168],[10,"Clone",169],[1,"unit"],[6,"Ordering",170],[10,"Ord",170],[10,"FromIterator",171],[1,"usize"],[10,"BufRead",172],[10,"Deref",173],[17,"Target"],[10,"DerefMut",173],[10,"FnOnce",160],[10,"Into",163],[10,"PartialEq",170],[10,"Debug",174],[10,"Extend",171],[10,"IntoIterator",171],[6,"Result",175],[1,"tuple"],[1,"u8"],[8,"Result",176],[10,"Write",172],[5,"Formatter",174],[8,"Result",174],[10,"Display",174],[10,"Hash",177],[10,"Hasher",177],[10,"IntoEither",0,178],[10,"Default",179],[10,"ExactSizeIterator",180],[10,"DoubleEndedIterator",181],[10,"PartialOrd",170],[5,"Context",182],[6,"Poll",183],[10,"Future",184],[10,"Read",172],[5,"String",185],[5,"Vec",186],[6,"SeekFrom",172],[1,"u64"],[10,"Seek",172],[5,"TypeId",187],[5,"Arguments",174]],"r":[[1,178],[2,161]],"b":[[11,"impl-AsMut%3CCStr%3E-for-Either%3CL,+R%3E"],[12,"impl-AsMut%3COsStr%3E-for-Either%3CL,+R%3E"],[13,"impl-AsMut%3Cstr%3E-for-Either%3CL,+R%3E"],[14,"impl-Either%3CL,+R%3E"],[15,"impl-AsMut%3CPath%3E-for-Either%3CL,+R%3E"],[16,"impl-AsMut%3C%5BTarget%5D%3E-for-Either%3CL,+R%3E"],[17,"impl-AsMut%3CTarget%3E-for-Either%3CL,+R%3E"],[20,"impl-AsRef%3C%5BTarget%5D%3E-for-Either%3CL,+R%3E"],[21,"impl-AsRef%3CCStr%3E-for-Either%3CL,+R%3E"],[22,"impl-AsRef%3Cstr%3E-for-Either%3CL,+R%3E"],[23,"impl-AsRef%3CTarget%3E-for-Either%3CL,+R%3E"],[24,"impl-Either%3CL,+R%3E"],[25,"impl-AsRef%3CPath%3E-for-Either%3CL,+R%3E"],[26,"impl-AsRef%3COsStr%3E-for-Either%3CL,+R%3E"],[68,"impl-Display-for-Either%3CL,+R%3E"],[69,"impl-Debug-for-Either%3CL,+R%3E"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAGUAFAAEAAAABgAAAAgABgAQAAIAFQADABoAFAAyAAAANQAAAD4ABABEAAUASwACAFAAAQBYAAAAWwABAGEAAQBoAAEAbwAXAIwACgCZAAEAnQACAA=="}],\ +["either",{"t":"GKFEPEPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNQQNNNNNNN","n":["Either","IntoEither","IterEither","Left","Left","Right","Right","all","all","any","any","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_pin_mut","as_pin_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","borrow","borrow","borrow_mut","borrow_mut","cause","clone","clone","clone_from","clone_into","clone_into","cmp","collect","collect","consume","count","count","deref","deref_mut","description","either","either_into","either_with","eq","expect_left","expect_right","extend","factor_err","factor_first","factor_into_iter","factor_iter","factor_iter_mut","factor_none","factor_ok","factor_second","fill_buf","find","find","find_map","find_map","flip","flush","fmt","fmt","fmt","fold","fold","for_both","for_each","for_each","from","from","from","hash","into","into","into","into_either","into_either","into_either_with","into_either_with","into_future","into_inner","into_iter","into_iter","into_iter","is_left","is_right","iter","iter_mut","last","last","left","left_and_then","left_or","left_or_default","left_or_else","len","len","map","map_either","map_either_with","map_left","map_right","next","next","next_back","next_back","nth","nth","nth_back","nth_back","partial_cmp","partition","partition","poll","position","position","read","read_exact","read_line","read_to_end","read_to_string","read_until","rfind","rfind","rfold","rfold","right","right_and_then","right_or","right_or_default","right_or_else","seek","size_hint","size_hint","source","to_owned","to_owned","to_string","try_from","try_from","try_into","try_into","try_left","try_right","type_id","type_id","unwrap_left","unwrap_right","write","write_all","write_fmt"],"q":[[0,"either"],[159,"core::iter::traits::iterator"],[160,"core::ops::function"],[161,"either::iterator"],[162,"core::convert"],[163,"std::ffi::os_str"],[164,"core::ffi::c_str"],[165,"std::path"],[166,"core::pin"],[167,"core::error"],[168,"core::option"],[169,"core::clone"],[170,"core::cmp"],[171,"core::iter::traits::collect"],[172,"std::io"],[173,"core::ops::deref"],[174,"core::fmt"],[175,"core::result"],[176,"std::io::error"],[177,"core::hash"],[178,"either::into_either"],[179,"core::default"],[180,"core::iter::traits::exact_size"],[181,"core::iter::traits::double_ended"],[182,"core::task::wake"],[183,"core::task::poll"],[184,"core::future::future"],[185,"alloc::string"],[186,"alloc::vec"],[187,"core::any"]],"i":[0,0,0,0,1,0,1,1,7,1,7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,7,1,7,1,1,7,1,1,7,1,1,7,1,1,7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,7,1,7,1,1,1,1,7,1,7,0,1,7,1,1,7,1,1,1,7,44,44,44,44,1,1,1,1,7,1,1,1,1,1,7,1,1,1,1,1,1,7,1,1,1,1,1,1,7,1,7,1,7,1,7,1,1,7,1,1,7,1,1,1,1,1,1,1,7,1,7,1,1,1,1,1,1,1,7,1,1,7,1,1,7,1,7,0,0,1,7,1,1,1,1,1],"f":"```````{{{b{ce}}i}df{{f{}{{h{}}}}}{}{{l{g}{{j{d}}}}}}{{{n{ce}}i}dff{}{{l{g}{{j{d}}}}}}10{{{b{ce}}}A`{{Ab{A`}}}{{Ab{A`}}}}{{{b{ce}}}Ad{{Ab{Ad}}}{{Ab{Ad}}}}{{{b{eg}}}{{Af{c}}}{}{{Ab{{Af{c}}}}}{{Ab{{Af{c}}}}}}{{{b{eg}}}c{}{{Ab{c}}}{{Ab{c}}}}{{{b{ce}}}Ah{{Ab{Ah}}}{{Ab{Ah}}}}{{{b{ce}}}{{b{ce}}}{}{}}{{{b{ce}}}Aj{{Ab{Aj}}}{{Ab{Aj}}}}{{{Al{{b{ce}}}}}{{b{{Al{c}}{Al{e}}}}}{}{}}0{{{b{ce}}}Ah{{An{Ah}}}{{An{Ah}}}}{{{b{ce}}}Ad{{An{Ad}}}{{An{Ad}}}}{{{b{eg}}}{{Af{c}}}{}{{An{{Af{c}}}}}{{An{{Af{c}}}}}}5{{{b{ce}}}A`{{An{A`}}}{{An{A`}}}}{{{b{eg}}}c{}{{An{c}}}{{An{c}}}}{{{b{ce}}}Aj{{An{Aj}}}{{An{Aj}}}}{ce{}{}}000{{{b{ce}}}{{Bb{B`}}}B`B`}{{{b{ce}}}{{b{ce}}}BdBd}{{{n{ce}}}{{n{ce}}}BdBd}{{{b{ce}}{b{ce}}}BfBdBd}{{ce}Bf{}{}}0{{{b{ce}}{b{ce}}}BhBjBj}{{{b{ce}}}if{{f{}{{h{}}}}}{}{{Bl{g}}}}{{{n{ce}}}iff{}{{Bl{g}}}}{{{b{ce}}Bn}BfC`C`}{{{b{ce}}}Bnf{{f{}{{h{}}}}}}{{{n{ce}}}Bnff}{{{b{ce}}}gCb{{Cb{}{{Cd{}}}}}{}}{{{b{ce}}}gCf{{Cf{}{{Cd{}}}}}{}}{{{b{ce}}}A`B`B`}{{{b{ce}}ik}g{}{}{}{{Ch{c}{{j{g}}}}}{{Ch{e}{{j{g}}}}}}{{{b{eg}}}c{}{{Cj{c}}}{{Cj{c}}}}{{{b{ce}}gkm}i{}{}{}{}{{Ch{gc}{{j{i}}}}}{{Ch{ge}{{j{i}}}}}}{{{b{ce}}{b{ce}}}dClCl}{{{b{ce}}A`}c{}Cn}{{{b{ce}}A`}eCn{}}{{{b{eg}}i}Bf{}{{D`{c}}}{{D`{c}}}{{Db{}{{h{c}}}}}}{{{b{{Dd{ce}}{Dd{ge}}}}}{{Dd{{b{cg}}e}}}{}{}{}}{{{b{{Df{ce}}{Df{cg}}}}}{{Df{c{b{eg}}}}}{}{}{}}{{{b{ce}}}nDbDb}{{{b{ce}}}n{}{}}0{{{b{{Bb{c}}{Bb{e}}}}}{{Bb{{b{ce}}}}}{}{}}{{{b{{Dd{ce}}{Dd{cg}}}}}{{Dd{c{b{eg}}}}}{}{}{}}{{{b{{Df{ce}}{Df{ge}}}}}{{Df{{b{cg}}e}}}{}{}{}}{{{b{ce}}}{{Dj{{Af{Dh}}}}}C`C`}{{{b{ce}}i}{{Bb{g}}}f{{f{}{{h{}}}}}{}{{l{g}{{j{d}}}}}}{{{n{ce}}i}{{Bb{g}}}ff{}{{l{g}{{j{d}}}}}}{{{b{ce}}k}{{Bb{i}}}f{{f{}{{h{}}}}}{}{}{{l{g}{{j{{Bb{i}}}}}}}}{{{n{ce}}k}{{Bb{i}}}ff{}{}{{l{g}{{j{{Bb{i}}}}}}}}{{{b{ce}}}{{b{ec}}}{}{}}{{{b{ce}}}{{Dj{Bf}}}DlDl}{{{b{ce}}Dn}E`CnCn}{{{b{ce}}Dn}E`EbEb}{{{n{ce}}Dn}E`CnCn}{{{b{ce}}gk}gf{{f{}{{h{}}}}}{}{}{{l{gi}{{j{g}}}}}}{{{n{ce}}gk}gff{}{}{{l{gi}{{j{g}}}}}}`{{{b{ce}}i}Bff{{f{}{{h{}}}}}{}{{l{g}}}}{{{n{ce}}i}Bfff{}{{l{g}}}}{cc{}}{{{Dd{ce}}}{{b{ec}}}{}{}}1{{{b{ce}}g}BfEdEdEf}{ce{}{}}{{{b{ce}}}{{Dd{ec}}}{}{}}1{{Ehd}{{b{EhEh}}}}0{{Ehc}{{b{EhEh}}}{{Ch{Eh}{{j{d}}}}}}0{c{}{}}{{{b{cc}}}c{}}5{{{b{ce}}}bDb{{Db{}{{h{}}}}}}6{{{b{ce}}}d{}{}}0{{{b{ce}}}b{}{}}0{{{b{ce}}}{{Bb{g}}}f{{f{}{{h{}}}}}{}}{{{n{ce}}}{{Bb{g}}}ff{}}{{{b{ce}}}{{Bb{c}}}{}{}}{{{b{ce}}i}{{b{ge}}}{}{}{}{{Ch{c}{{j{{b{ge}}}}}}}}{{{b{ce}}c}c{}{}}{{{b{ce}}}cEj{}}{{{b{ce}}g}c{}{}{{Ch{e}{{j{c}}}}}}{{{b{ce}}}BnEl{{El{}{{h{}}}}}}{{{n{ce}}}BnElEl}{{{b{cc}}g}{{b{ee}}}{}{}{{Ch{c}{{j{e}}}}}}{{{b{ce}}im}{{b{gk}}}{}{}{}{{Ch{c}{{j{g}}}}}{}{{Ch{e}{{j{k}}}}}}{{{b{ce}}gko}{{b{im}}}{}{}{}{}{{Ch{gc}{{j{i}}}}}{}{{Ch{ge}{{j{m}}}}}}{{{b{ce}}i}{{b{ge}}}{}{}{}{{Ch{c}{{j{g}}}}}}{{{b{ce}}i}{{b{cg}}}{}{}{}{{Ch{e}{{j{g}}}}}}=<{{{b{ce}}}{{Bb{g}}}En{{En{}{{h{}}}}}{}}{{{n{ce}}}{{Bb{g}}}EnEn{}}{{{b{ce}}Bn}{{Bb{g}}}f{{f{}{{h{}}}}}{}}{{{n{ce}}Bn}{{Bb{g}}}ff{}}{{{b{ce}}Bn}{{Bb{g}}}En{{En{}{{h{}}}}}{}}{{{n{ce}}Bn}{{Bb{g}}}EnEn{}}{{{b{ce}}{b{ce}}}{{Bb{Bh}}}F`F`}{{{b{ce}}i}{{Df{kk}}}f{{f{}{{h{}}}}}{}{{l{g}{{j{d}}}}}{Ej{D`{g}}}}{{{n{ce}}i}{{Df{kk}}}ff{}{{l{g}{{j{d}}}}}{Ej{D`{g}}}}{{{Al{{b{ce}}}}Fb}{{Fd{g}}}Ff{{Ff{}{{j{}}}}}{}}{{{b{ce}}i}{{Bb{Bn}}}f{{f{}{{h{}}}}}{}{{l{g}{{j{d}}}}}}{{{n{ce}}i}{{Bb{Bn}}}ff{}{{l{g}{{j{d}}}}}}{{{b{ce}}{Af{Dh}}}{{Dj{Bn}}}FhFh}{{{b{ce}}{Af{Dh}}}{{Dj{Bf}}}FhFh}{{{b{ce}}Fj}{{Dj{Bn}}}C`C`}{{{b{ce}}{Fl{Dh}}}{{Dj{Bn}}}FhFh}{{{b{ce}}Fj}{{Dj{Bn}}}FhFh}{{{b{ce}}Dh{Fl{Dh}}}{{Dj{Bn}}}C`C`}{{{b{ce}}i}{{Bb{g}}}En{{En{}{{h{}}}}}{}{{l{g}{{j{d}}}}}}{{{n{ce}}i}{{Bb{g}}}EnEn{}{{l{g}{{j{d}}}}}}{{{b{ce}}gk}gEn{{En{}{{h{}}}}}{}{}{{l{gi}{{j{g}}}}}}{{{n{ce}}gk}gEnEn{}{}{{l{gi}{{j{g}}}}}}{{{b{ce}}}{{Bb{e}}}{}{}}{{{b{ce}}i}{{b{cg}}}{}{}{}{{Ch{e}{{j{{b{cg}}}}}}}}{{{b{ce}}e}e{}{}}{{{b{ce}}}e{}Ej}{{{b{ce}}g}e{}{}{{Ch{c}{{j{e}}}}}}{{{b{ce}}Fn}{{Dj{G`}}}GbGb}{{{b{ce}}}{{Df{Bn{Bb{Bn}}}}}f{{f{}{{h{}}}}}}{{{n{ce}}}{{Df{Bn{Bb{Bn}}}}}ff}{{{b{ce}}}{{Bb{B`}}}B`B`}{ce{}{}}0{cFj{}}{c{{Dd{e}}}{}{}}000``{cGd{}}0{{{b{ce}}}c{}Cn}{{{b{ce}}}eCn{}}{{{b{ce}}{Af{Dh}}}{{Dj{Bn}}}DlDl}{{{b{ce}}{Af{Dh}}}{{Dj{Bf}}}DlDl}{{{b{ce}}Gf}{{Dj{Bf}}}DlDl}","D":"Gd","p":[[6,"Either",0],[1,"bool"],[10,"Iterator",159],[17,"Item"],[17,"Output"],[10,"FnMut",160],[5,"IterEither",0,161],[1,"str"],[10,"AsMut",162],[5,"OsStr",163],[1,"slice"],[5,"CStr",164],[5,"Path",165],[5,"Pin",166],[10,"AsRef",162],[10,"Error",167],[6,"Option",168],[10,"Clone",169],[1,"unit"],[6,"Ordering",170],[10,"Ord",170],[10,"FromIterator",171],[1,"usize"],[10,"BufRead",172],[10,"Deref",173],[17,"Target"],[10,"DerefMut",173],[10,"FnOnce",160],[10,"Into",162],[10,"PartialEq",170],[10,"Debug",174],[10,"Extend",171],[10,"IntoIterator",171],[6,"Result",175],[1,"tuple"],[1,"u8"],[8,"Result",176],[10,"Write",172],[5,"Formatter",174],[8,"Result",174],[10,"Display",174],[10,"Hash",177],[10,"Hasher",177],[10,"IntoEither",0,178],[10,"Default",179],[10,"ExactSizeIterator",180],[10,"DoubleEndedIterator",181],[10,"PartialOrd",170],[5,"Context",182],[6,"Poll",183],[10,"Future",184],[10,"Read",172],[5,"String",185],[5,"Vec",186],[6,"SeekFrom",172],[1,"u64"],[10,"Seek",172],[5,"TypeId",187],[5,"Arguments",174]],"r":[[1,178],[2,161]],"b":[[11,"impl-AsMut%3Cstr%3E-for-Either%3CL,+R%3E"],[12,"impl-AsMut%3COsStr%3E-for-Either%3CL,+R%3E"],[13,"impl-AsMut%3C%5BTarget%5D%3E-for-Either%3CL,+R%3E"],[14,"impl-AsMut%3CTarget%3E-for-Either%3CL,+R%3E"],[15,"impl-AsMut%3CCStr%3E-for-Either%3CL,+R%3E"],[16,"impl-Either%3CL,+R%3E"],[17,"impl-AsMut%3CPath%3E-for-Either%3CL,+R%3E"],[20,"impl-AsRef%3CCStr%3E-for-Either%3CL,+R%3E"],[21,"impl-AsRef%3COsStr%3E-for-Either%3CL,+R%3E"],[22,"impl-AsRef%3C%5BTarget%5D%3E-for-Either%3CL,+R%3E"],[23,"impl-Either%3CL,+R%3E"],[24,"impl-AsRef%3Cstr%3E-for-Either%3CL,+R%3E"],[25,"impl-AsRef%3CTarget%3E-for-Either%3CL,+R%3E"],[26,"impl-AsRef%3CPath%3E-for-Either%3CL,+R%3E"],[68,"impl-Debug-for-Either%3CL,+R%3E"],[69,"impl-Display-for-Either%3CL,+R%3E"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAGUAFwAEAAAABgAAAAgACAASAAAAFQACABkAFQAyAAAANQAAAD4ABABEAAUASwABAE4AAABQAAAAUgAAAFgAAABaAAAAXAAAAGEAAQBoAAEAbwAXAIwACgCZAAEAnQACAA=="}],\ ["enum_dispatch",{"t":"X","n":["enum_dispatch"],"q":[[0,"enum_dispatch"]],"i":[0],"f":"`","D":"d","p":[],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAAAAAA="}],\ ["equivalent",{"t":"KKMM","n":["Comparable","Equivalent","compare","equivalent"],"q":[[0,"equivalent"],[4,"core::cmp"],[5,"core::marker"]],"i":[0,0,1,4],"f":"``{{bc}df}{{hc}jf}","D":"j","p":[[10,"Comparable",0],[6,"Ordering",4],[10,"Sized",5],[10,"Equivalent",0],[1,"bool"]],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAAAAAA="}],\ ["fastrand",{"t":"FHNHNHNNNHNHNHNNNNHNNHNHNNNNNHNHNHNHNHNHNNHNHNNHNHNNNNNHNHNHNHNHNHNHNN","n":["Rng","alphabetic","alphabetic","alphanumeric","alphanumeric","bool","bool","borrow","borrow_mut","char","char","choice","choice","choose_multiple","choose_multiple","clone","clone_into","default","digit","digit","eq","f32","f32","f64","f64","fill","fmt","fork","from","get_seed","get_seed","i128","i128","i16","i16","i32","i32","i64","i64","i8","i8","into","isize","isize","lowercase","lowercase","new","seed","seed","shuffle","shuffle","to_owned","try_from","try_into","type_id","u128","u128","u16","u16","u32","u32","u64","u64","u8","u8","uppercase","uppercase","usize","usize","with_seed"],"q":[[0,"fastrand"],[70,"core::ops::range"],[71,"core::option"],[72,"core::iter::traits::collect"],[73,"alloc::vec"],[74,"core::iter::traits::iterator"],[75,"core::fmt"],[76,"core::result"],[77,"core::any"],[78,"fastrand::global_rng"]],"i":[0,0,2,0,2,0,2,2,2,0,2,0,2,0,2,2,2,2,0,2,2,0,2,0,2,2,2,2,2,0,2,0,2,0,2,0,2,0,2,0,2,2,0,2,0,2,2,0,2,0,2,2,2,2,2,0,2,0,2,0,2,0,2,0,2,0,2,0,2,2],"f":"`{{}b}{db}10{{}f}{df}{ce{}{}}0{cb{{h{b}}}}{{dc}b{{h{b}}}}{cjl}{{dc}jl}{{cn}A`Ab}{{dcn}A`Ab}{dd}{{ce}Ad{}{}}{{}d}{Afb}{{dAf}b}{{dd}f}{{}Ah}{dAh}{{}Aj}{dAj}{{d{An{Al}}}Ad}{{dB`}Bb};{cc{}}{{}Bd}{dBd}{cBf{{h{Bf}}}}{{dc}Bf{{h{Bf}}}}{cBh{{h{Bh}}}}{{dc}Bh{{h{Bh}}}}{cBj{{h{Bj}}}}{{dc}Bj{{h{Bj}}}}{cBl{{h{Bl}}}}{{dc}Bl{{h{Bl}}}}{cBn{{h{Bn}}}}{{dc}Bn{{h{Bn}}}}{ce{}{}}{cC`{{h{C`}}}}{{dc}C`{{h{C`}}}}{{}b}{db}{{}d}{BdAd}{{dBd}Ad}{{{An{c}}}Ad{}}{{d{An{c}}}Ad{}}9{c{{Cb{e}}}{}{}}0{cCd{}}{cCf{{h{Cf}}}}{{dc}Cf{{h{Cf}}}}{cCh{{h{Ch}}}}{{dc}Ch{{h{Ch}}}}{cAf{{h{Af}}}}{{dc}Af{{h{Af}}}}{cBd{{h{Bd}}}}{{dc}Bd{{h{Bd}}}}{cAl{{h{Al}}}}{{dc}Al{{h{Al}}}}{{}b}{db}{cn{{h{n}}}}{{dc}n{{h{n}}}}{Bdd}","D":"Gl","p":[[1,"char"],[5,"Rng",0],[1,"bool"],[10,"RangeBounds",70],[6,"Option",71],[10,"IntoIterator",72],[1,"usize"],[5,"Vec",73],[10,"Iterator",74],[1,"unit"],[1,"u32"],[1,"f32"],[1,"f64"],[1,"u8"],[1,"slice"],[5,"Formatter",75],[8,"Result",75],[1,"u64"],[1,"i128"],[1,"i16"],[1,"i32"],[1,"i64"],[1,"i8"],[1,"isize"],[6,"Result",76],[5,"TypeId",77],[1,"u128"],[1,"u16"]],"r":[[1,78],[3,78],[5,78],[9,78],[11,78],[13,78],[18,78],[21,78],[23,78],[29,78],[31,78],[33,78],[35,78],[37,78],[39,78],[42,78],[44,78],[47,78],[49,78],[55,78],[57,78],[59,78],[61,78],[63,78],[65,78],[67,78]],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAEAAAAAAAgAEAAAAAgACQARABUAGwA0ADUANgA3AA=="}],\ @@ -97,7 +97,7 @@ var searchIndex = new Map(JSON.parse('[\ ["scheduler",{"t":"KGGGPPPPPPNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNCCNNNNNNNNNKFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Host","HostIter","Scheduler","SchedulerScope","ThreadPerCore","ThreadPerCore","ThreadPerCore","ThreadPerHost","ThreadPerHost","ThreadPerHost","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","core_affinity","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","for_each","from","from","from","init","init","init","into","into","into","join","parallelism","run","run_with_data","run_with_hosts","scope","thread_per_core","thread_per_host","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","Host","HostIter","SchedulerScope","ThreadPerCoreSched","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","for_each","from","from","from","init","init","init","into","into","into","join","new","parallelism","run","run_with_data","run_with_hosts","scope","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","Host","HostIter","SchedulerScope","ThreadPerHostSched","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","for_each","from","from","from","init","init","init","into","into","into","join","new","parallelism","run","run_with_data","run_with_hosts","scope","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id"],"q":[[0,"scheduler"],[53,"scheduler::thread_per_core"],[98,"scheduler::thread_per_host"],[143,"core::option"],[144,"core::ops::function"],[145,"core::marker"],[146,"core::result"],[147,"core::any"],[148,"core::iter::traits::collect"],[149,"core::cell"],[150,"std::thread::local"]],"i":[0,0,0,0,9,10,5,9,10,5,9,10,5,9,10,5,0,9,10,5,9,10,5,9,10,5,5,9,10,5,9,10,5,9,10,5,9,9,10,10,10,9,0,0,9,10,5,9,10,5,9,10,5,0,0,0,0,20,24,18,20,24,18,20,24,18,20,24,18,20,24,18,18,20,24,18,20,24,18,20,24,18,20,20,20,24,24,24,20,20,24,18,20,24,18,20,24,18,0,0,0,0,27,30,25,27,30,25,27,30,25,27,30,25,27,30,25,25,27,30,25,27,30,25,27,30,25,27,27,27,30,30,30,27,27,30,25,27,30,25,27,30,25],"f":"``````````{ce{}{}}00000{{}{{d{b}}}}{fc{}}00000{fh}00{{{j{c}}e}hl{{A`{c}{{n{c}}}}}}{cc{}}00{{}f}00666{{{Ab{c}}}hl}{{{Ab{c}}}fl}{{{Ad{c}}e}hl{{Af{f}}AhAj}}{{{Ad{c}}{Al{e}}g}hlAh{{Af{f{j{c}}e}}AjAh}}{{{Ad{c}}e}hl{{Af{f{j{c}}}}AjAh}}{{{Ab{c}}e}hl{{An{{Ad{c}}}}}}``{c{{B`{e}}}{}{}}00000{cBb{}}00````>>>>>><<<<<<;;;{{{Bd{c}}e}hBf{{A`{c}{{n{c}}}}}}:::999???{{{Bh{c}}}hBf}{{{Al{{d{b}}}}eBj}{{Bh{c}}}Bf{{Bn{}{{Bl{c}}}}}}{{{Bh{c}}}fBf}{{{C`{c}}e}hBf{{Af{f}}AhAj}}{{{C`{c}}{Al{e}}g}hBfAh{{Af{f{Bd{c}}e}}AjAh}}{{{C`{c}}e}hBf{{Af{f{Bd{c}}}}AjAh}}{{{Bh{c}}e}hBf{{An{{C`{c}}}}}}999999888````{ce{}{}}00000{fc{}}00000{fh}00{{{Cb{c}}e}hCd{{A`{c}{{n{c}}}}}}{cc{}}00{{}f}00555{{{Cf{c}}}hCd}{{{Al{{d{b}}}}{Cj{{Ch{{d{c}}}}}}e}{{Cf{c}}}Cd{{Bn{}{{Bl{c}}}}}}{{{Cf{c}}}fCd}{{{Cl{c}}e}hCd{{Af{f}}AhAj}}{{{Cl{c}}{Al{e}}g}hCdAh{{Af{f{Cb{c}}e}}AjAh}}{{{Cl{c}}e}hCd{{Af{f{Cb{c}}}}AjAh}}{{{Cf{c}}e}hCd{{An{{Cl{c}}}}}}{c{{B`{e}}}{}{}}00000{cBb{}}00","D":"Fl","p":[[1,"u32"],[6,"Option",143],[1,"usize"],[1,"unit"],[6,"HostIter",0],[10,"Host",0],[17,"Output"],[10,"FnMut",144],[6,"Scheduler",0],[6,"SchedulerScope",0],[10,"Fn",144],[10,"Sync",145],[10,"Send",145],[1,"slice"],[10,"FnOnce",144],[6,"Result",146],[5,"TypeId",147],[5,"HostIter",53],[10,"Host",53],[5,"ThreadPerCoreSched",53],[1,"bool"],[17,"Item"],[10,"IntoIterator",148],[5,"SchedulerScope",53],[5,"HostIter",98],[10,"Host",98],[5,"ThreadPerHostSched",98],[5,"RefCell",149],[5,"LocalKey",150],[5,"SchedulerScope",98]],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAFkACwABAAAABQALABIACAAfAAIALQAJADoADgBNAAIAWgAJAGcADgB6AAIAhwAIAA=="}],\ ["schemars",{"t":"KYYIIPIPCNMCQQNMCKFFNNMNNNNNNNNNNNNONNNNNNNNONNNNNNONNOONNNNNNNNNNNNNNNONNNPFPPGPFPPFPPFFGFPGPFFPNNNNNNNNNNNOOOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONONNNNNNNNOOOONNNNNNNNNNNOONNNNNNNNNNNOOOONNNNNNNNNNNONNNNNNNNNNNNNNNNNNNOOONNNNNNNNNNNNNNOOOOOONOOOOOONNONONOONNOOOOOOOONNNNNNNNNNNNONOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOFFFKNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNHNHNNHNNNN","n":["JsonSchema","JsonSchema","JsonSchema_repr","Map","MapEntry","Occupied","Set","Vacant","gen","is_referenceable","json_schema","schema","schema_for","schema_for_value","schema_id","schema_name","visit","GenVisitor","SchemaGenerator","SchemaSettings","__clone_box","__clone_box","as_any","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","default","default","definitions","definitions_mut","definitions_path","dereference","draft07","draft2019_09","fmt","fmt","from","from","from","inline_subschemas","into","into","into_generator","into_root_schema_for","into_root_schema_for_value","make_extensible","meta_schema","new","openapi3","option_add_null_type","option_nullable","root_schema_for","root_schema_for_value","schema_for_any","schema_for_none","settings","subschema_for","take_definitions","to_owned","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","visitors","visitors_mut","with","with_visitor","Array","ArrayValidation","Bool","Boolean","InstanceType","Integer","Metadata","Null","Number","NumberValidation","Object","Object","ObjectValidation","RootSchema","Schema","SchemaObject","Single","SingleOrVec","String","StringValidation","SubschemaValidation","Vec","__clone_box","__clone_box","__clone_box","__clone_box","__clone_box","__clone_box","__clone_box","__clone_box","__clone_box","__clone_box","__clone_box","additional_items","additional_properties","all_of","any_of","array","array","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","const_value","contains","contains","default","default","default","default","default","default","default","default","default","definitions","deprecated","description","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","else_schema","enum_values","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","examples","exclusive_maximum","exclusive_minimum","extensions","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","format","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","has_type","hash","id","if_schema","instance_type","into","into","into","into","into","into","into","into","into","into","into","into_object","is_ref","is_ref","items","max_items","max_length","max_properties","maximum","meta_schema","metadata","metadata","min_items","min_length","min_properties","minimum","multiple_of","new_ref","new_ref","not","number","number","object","object","one_of","partial_cmp","partial_cmp","pattern","pattern_properties","properties","property_names","read_only","reference","required","schema","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","string","string","subschemas","subschemas","then_schema","title","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unique_items","write_only","RemoveRefSiblings","ReplaceBoolSchemas","SetSingleExample","Visitor","__clone_box","__clone_box","__clone_box","as_any","as_any","as_any","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","fmt","fmt","fmt","from","from","from","into","into","into","retain_examples","skip_additional_properties","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","visit_root_schema","visit_root_schema","visit_schema","visit_schema","visit_schema","visit_schema_object","visit_schema_object","visit_schema_object","visit_schema_object","visit_schema_object"],"q":[[0,"schemars"],[17,"schemars::gen"],[75,"schemars::schema"],[345,"schemars::visit"],[400,"alloc::borrow"],[401,"alloc::string"],[402,"dyn_clone::sealed"],[403,"core::any"],[404,"core::option"],[405,"core::fmt"],[406,"serde_json::error"],[407,"core::result"],[408,"core::marker"],[409,"serde::ser"],[410,"core::iter::traits::iterator"],[411,"core::ops::function"],[412,"core::clone"],[413,"core::cmp"],[414,"serde::de"],[415,"alloc::vec"],[416,"core::hash"],[417,"schemars_derive"]],"i":[0,0,0,0,0,50,0,50,0,51,51,0,0,0,51,51,0,0,0,0,11,2,9,11,2,11,2,11,2,11,2,11,2,2,2,11,2,11,11,11,2,11,2,2,11,11,2,11,2,2,2,11,2,11,11,11,2,2,2,2,2,2,2,11,2,11,2,11,2,11,2,11,2,11,11,35,0,3,35,0,35,0,35,35,0,3,35,0,0,0,0,36,0,35,0,0,36,3,16,21,30,31,32,33,29,34,35,36,29,34,31,31,21,21,3,16,21,30,31,32,33,29,34,35,36,3,16,21,30,31,32,33,29,34,35,36,3,16,21,30,31,32,33,29,34,35,36,3,16,21,30,31,32,33,29,34,35,36,35,36,21,36,29,16,21,30,31,32,33,29,34,30,16,30,30,3,16,21,30,31,32,33,29,34,35,36,31,21,3,16,21,30,31,32,33,29,34,35,36,30,32,32,21,3,16,21,30,31,32,33,29,34,35,36,21,3,3,3,16,21,21,30,31,32,33,29,34,35,36,36,36,36,21,35,30,31,21,3,16,21,30,31,32,33,29,34,35,36,3,3,21,29,29,33,34,32,16,21,21,29,33,34,32,32,3,21,31,21,21,21,21,31,35,36,33,34,34,34,30,21,34,16,3,16,21,30,31,32,33,29,34,35,36,21,21,21,21,31,30,3,16,21,30,31,32,33,29,34,35,36,3,16,21,30,31,32,33,29,34,35,36,3,16,21,30,31,32,33,29,34,35,36,3,16,21,30,31,32,33,29,34,35,36,29,30,0,0,0,0,47,48,49,47,48,49,47,48,49,47,48,49,47,48,49,47,48,49,47,48,49,47,48,49,47,48,49,49,47,47,48,49,47,48,49,47,48,49,47,48,49,0,26,0,26,47,0,26,47,48,49],"f":"`````````{{}b}{df}```{{}{{j{h}}}}{{}l}````{{cn}A`{}}0{AbAd}{ce{}{}}000{AfAf}{dd}{{ce}A`{}{}}0{{}Af}{{}d}{d{{Ah{lf}}}}0`{{df}{{Aj{f}}}}33{{AfAl}An}{{dAl}An}{cc{}}{Afd}1`;;0{dB`}{{dc}{{Bd{B`Bb}}}{BfBh}}{{dBj}A`}`3:``21{df}0{dAf}1:{ce{}{}}0{c{{Bd{e}}}{}{}}000{cBl{}}0`{d{{`{{C`{}{{Bn{Ab}}}}}}}}{{Afc}Af{{Cb{Af}}}}{{Afc}Af{CdCfCh}}``````````````````````{{cn}A`{}}0000000000````{BjCj}`7777777777777777777777{ff}{B`B`}{BjBj}{ClCl}{CnCn}{D`D`}{DbDb}{CjCj}{DdDd}{DfDf}{{{Dh{c}}}{{Dh{c}}}Ch}{{ce}A`{}{}}0000000000{{DfDf}Dj}{{{Dh{c}}{Dh{c}}}DjDl}`{{{Dh{c}}c}bDn}`{{}B`}{{}Bj}{{}Cl}{{}Cn}{{}D`}{{}Db}{{}Cj}{{}Dd}````{c{{Bd{f}}}E`}{c{{Bd{B`}}}E`}{c{{Bd{Bj}}}E`}{c{{Bd{Cl}}}E`}{c{{Bd{Cn}}}E`}{c{{Bd{D`}}}E`}{c{{Bd{Db}}}E`}{c{{Bd{Cj}}}E`}{c{{Bd{Dd}}}E`}{c{{Bd{Df}}}E`}{c{{Bd{{Dh{e}}}}}E`Eb}``{{ff}b}{{B`B`}b}{{BjBj}b}{{ClCl}b}{{CnCn}b}{{D`D`}b}{{DbDb}b}{{CjCj}b}{{DdDd}b}{{DfDf}b}{{{Dh{c}}{Dh{c}}}bDn}````{{fAl}An}{{B`Al}An}{{BjAl}An}{{ClAl}An}{{CnAl}An}{{D`Al}An}{{DbAl}An}{{CjAl}An}{{DdAl}An}{{DfAl}An}{{{Dh{c}}Al}AnCf}`{bf}{cc{}}{Bjf}1{fBj}22222222{Edc{}}{{{Ef{c}}}{{Dh{c}}}{}}4{c{{Dh{c}}}{}}{{BjDf}b}{{Dfc}A`Eh}```{ce{}{}}00000000006{fb}{Bjb}``````{BjCl}``````{lf}{lBj}`{BjD`}`{BjDd}``{{DfDf}{{Aj{Dj}}}}{{{Dh{c}}{Dh{c}}}{{Aj{Dj}}}Ej}````````{{fc}BdEl}{{B`c}BdEl}{{Bjc}BdEl}{{Clc}BdEl}{{Cnc}BdEl}{{D`c}BdEl}{{Dbc}BdEl}{{Cjc}BdEl}{{Ddc}BdEl}{{Dfc}BdEl}{{{Dh{c}}e}BdBhEl}{BjDb}`{BjCn}```{ce{}{}}0000000000{c{{Bd{e}}}{}{}}000000000000000000000{cBl{}}0000000000``````{{cn}A`{}}00{cAd{}}00444444{EnEn}{F`F`}{FbFb}{{ce}A`{}{}}00{{EnAl}An}{{F`Al}An}{{FbAl}An}{cc{}}00<<<``<<<;;;;;;:::{{cB`}A`{CdBf}}{{CdB`}A`}{{cf}A`{CdBf}}{{Cdf}A`}{{Enf}A`}{{cBj}A`{CdBf}}{{CdBj}A`}{{EnBj}A`}{{F`Bj}A`}{{FbBj}A`}","D":"ADj","p":[[1,"bool"],[5,"SchemaGenerator",17],[6,"Schema",75],[1,"str"],[6,"Cow",400],[5,"String",401],[5,"Private",402],[1,"unit"],[10,"GenVisitor",17],[10,"Any",403],[5,"SchemaSettings",17],[8,"Map",0],[6,"Option",404],[5,"Formatter",405],[8,"Result",405],[5,"RootSchema",75],[5,"Error",406],[6,"Result",407],[10,"Sized",408],[10,"Serialize",409],[5,"SchemaObject",75],[5,"TypeId",403],[17,"Item"],[10,"Iterator",410],[10,"FnOnce",411],[10,"Visitor",345],[10,"Debug",405],[10,"Clone",412],[5,"ArrayValidation",75],[5,"Metadata",75],[5,"SubschemaValidation",75],[5,"NumberValidation",75],[5,"StringValidation",75],[5,"ObjectValidation",75],[6,"InstanceType",75],[6,"SingleOrVec",75],[6,"Ordering",413],[10,"Ord",413],[10,"PartialEq",413],[10,"Deserializer",414],[10,"Deserialize",414],[1,"never"],[5,"Vec",415],[10,"Hasher",416],[10,"PartialOrd",413],[10,"Serializer",409],[5,"ReplaceBoolSchemas",345],[5,"RemoveRefSiblings",345],[5,"SetSingleExample",345],[8,"MapEntry",0],[10,"JsonSchema",0]],"r":[[1,417],[2,417]],"b":[[215,"impl-From%3Cbool%3E-for-Schema"],[217,"impl-From%3CSchemaObject%3E-for-Schema"],[229,"impl-From%3CVec%3CT%3E%3E-for-SingleOrVec%3CT%3E"],[231,"impl-From%3CT%3E-for-SingleOrVec%3CT%3E"]],"c":"OjAAAAEAAAAAAAIAEAAAADMAOwA8AA==","e":"OzAAAAEAAOsAIgACAAEAFQABABgACQAoAAEAKwAAADMAAAA7AAEAQAAHAEwAAABPAAAAUQAAAFMAAQBXAAAAXAAAAF4AAABhAAsAcwAtAKQABwCwAAoAvQAKAMwACgDYAAAA2gAAANwAAADlAAEA6AAAAOoAAAARAQEAGwEKACwBKwBeARQAewELAIsBAACOAQIA"}],\ ["schemars_derive",{"t":"YY","n":["JsonSchema","JsonSchema_repr"],"q":[[0,"schemars_derive"]],"i":[0,0],"f":"``","D":"`","p":[],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAEAAAAAAAIAEAAAAAAAAQACAA=="}],\ -["serde",{"t":"KYKRRRKYRRRRRRRKNNNCMMMMMMMMMNMMMMMMMMMMMMMMMNMMMMMMQNNCMMMMMMNMMMMMMMMMMMMMMMMNMMMMMMMPPPKKKKRPKKRRRRRKPFKPKPPPPPKPEPPPGPPPRRRKKNNNNNNNNMNMMNMMMMMMMMNMMMMMMMMMMMMMMMNMMMMMMNNNMNMNNNNNNNNNMNNNNNNMNMNNNMNMNNMNNNNNNNMNNMNNCNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFFFFFFFFFFFFFFFFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKRRRRRRRRFRRRRRRRRKKRKRKRKRKRKRKRKENNNNNMMMMMMMMNNNNNNNNNNMMMMMMNNNMMMMMMNNNNNMMMMMNMMMMMMMMMMMMNMMMMMMMMNNNNNN","n":["Deserialize","Deserialize","Deserializer","Error","Error","Ok","Serialize","Serialize","SerializeMap","SerializeSeq","SerializeStruct","SerializeStructVariant","SerializeTuple","SerializeTupleStruct","SerializeTupleVariant","Serializer","collect_map","collect_seq","collect_str","de","deserialize","deserialize_any","deserialize_bool","deserialize_byte_buf","deserialize_bytes","deserialize_char","deserialize_enum","deserialize_f32","deserialize_f64","deserialize_i128","deserialize_i16","deserialize_i32","deserialize_i64","deserialize_i8","deserialize_identifier","deserialize_ignored_any","deserialize_map","deserialize_newtype_struct","deserialize_option","deserialize_seq","deserialize_str","deserialize_string","deserialize_struct","deserialize_tuple","deserialize_tuple_struct","deserialize_u128","deserialize_u16","deserialize_u32","deserialize_u64","deserialize_u8","deserialize_unit","deserialize_unit_struct","forward_to_deserialize_any","is_human_readable","is_human_readable","ser","serialize","serialize_bool","serialize_bytes","serialize_char","serialize_f32","serialize_f64","serialize_i128","serialize_i16","serialize_i32","serialize_i64","serialize_i8","serialize_map","serialize_newtype_struct","serialize_newtype_variant","serialize_none","serialize_seq","serialize_some","serialize_str","serialize_struct","serialize_struct_variant","serialize_tuple","serialize_tuple_struct","serialize_tuple_variant","serialize_u128","serialize_u16","serialize_u32","serialize_u64","serialize_u8","serialize_unit","serialize_unit_struct","serialize_unit_variant","Bool","Bytes","Char","Deserialize","DeserializeOwned","DeserializeSeed","Deserializer","Deserializer","Enum","EnumAccess","Error","Error","Error","Error","Error","Error","Expected","Float","IgnoredAny","IntoDeserializer","Map","MapAccess","NewtypeStruct","NewtypeVariant","Option","Other","Seq","SeqAccess","Signed","StdError","Str","StructVariant","TupleVariant","Unexpected","Unit","UnitVariant","Unsigned","Value","Value","Variant","VariantAccess","Visitor","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","custom","default","deserialize","deserialize","deserialize","deserialize_any","deserialize_bool","deserialize_byte_buf","deserialize_bytes","deserialize_char","deserialize_enum","deserialize_f32","deserialize_f64","deserialize_i128","deserialize_i16","deserialize_i32","deserialize_i64","deserialize_i8","deserialize_identifier","deserialize_ignored_any","deserialize_map","deserialize_newtype_struct","deserialize_option","deserialize_seq","deserialize_str","deserialize_string","deserialize_struct","deserialize_tuple","deserialize_tuple_struct","deserialize_u128","deserialize_u16","deserialize_u32","deserialize_u64","deserialize_u8","deserialize_unit","deserialize_unit_struct","duplicate_field","eq","eq","expecting","expecting","fmt","fmt","fmt","fmt","fmt","fmt","from","from","into","into","into_deserializer","invalid_length","invalid_type","invalid_value","is_human_readable","missing_field","newtype_variant","newtype_variant_seed","next_element","next_element_seed","next_entry","next_entry_seed","next_key","next_key_seed","next_value","next_value_seed","size_hint","size_hint","struct_variant","to_owned","to_owned","to_string","try_from","try_from","try_into","try_into","tuple_variant","type_id","type_id","unit_variant","unknown_field","unknown_variant","value","variant","variant_seed","visit_bool","visit_bool","visit_borrowed_bytes","visit_borrowed_str","visit_byte_buf","visit_bytes","visit_bytes","visit_char","visit_enum","visit_enum","visit_f32","visit_f64","visit_f64","visit_i128","visit_i128","visit_i16","visit_i32","visit_i64","visit_i64","visit_i8","visit_map","visit_map","visit_newtype_struct","visit_newtype_struct","visit_none","visit_none","visit_seq","visit_seq","visit_some","visit_some","visit_str","visit_str","visit_string","visit_u128","visit_u128","visit_u16","visit_u32","visit_u64","visit_u64","visit_u8","visit_unit","visit_unit","BoolDeserializer","BorrowedBytesDeserializer","BorrowedStrDeserializer","BytesDeserializer","CharDeserializer","CowStrDeserializer","EnumAccessDeserializer","Error","F32Deserializer","F64Deserializer","I128Deserializer","I16Deserializer","I32Deserializer","I64Deserializer","I8Deserializer","IsizeDeserializer","MapAccessDeserializer","MapDeserializer","SeqAccessDeserializer","SeqDeserializer","StrDeserializer","StringDeserializer","U128Deserializer","U16Deserializer","U32Deserializer","U64Deserializer","U8Deserializer","UnitDeserializer","UsizeDeserializer","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","custom","custom","description","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","end","end","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","next_element_seed","next_element_seed","next_entry_seed","next_key_seed","next_value_seed","size_hint","size_hint","size_hint","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","variant_seed","variant_seed","variant_seed","variant_seed","variant_seed","variant_seed","Error","Error","Error","Error","Error","Error","Error","Error","Error","Impossible","Ok","Ok","Ok","Ok","Ok","Ok","Ok","Ok","Serialize","SerializeMap","SerializeMap","SerializeSeq","SerializeSeq","SerializeStruct","SerializeStruct","SerializeStructVariant","SerializeStructVariant","SerializeTuple","SerializeTuple","SerializeTupleStruct","SerializeTupleStruct","SerializeTupleVariant","SerializeTupleVariant","Serializer","StdError","borrow","borrow_mut","collect_map","collect_seq","collect_str","custom","end","end","end","end","end","end","end","end","end","end","end","end","end","end","from","into","is_human_readable","serialize","serialize_bool","serialize_bytes","serialize_char","serialize_element","serialize_element","serialize_element","serialize_element","serialize_entry","serialize_f32","serialize_f64","serialize_field","serialize_field","serialize_field","serialize_field","serialize_field","serialize_field","serialize_field","serialize_field","serialize_i128","serialize_i16","serialize_i32","serialize_i64","serialize_i8","serialize_key","serialize_key","serialize_map","serialize_newtype_struct","serialize_newtype_variant","serialize_none","serialize_seq","serialize_some","serialize_str","serialize_struct","serialize_struct_variant","serialize_tuple","serialize_tuple_struct","serialize_tuple_variant","serialize_u128","serialize_u16","serialize_u32","serialize_u64","serialize_u8","serialize_unit","serialize_unit_struct","serialize_unit_variant","serialize_value","serialize_value","skip_field","skip_field","try_from","try_into","type_id"],"q":[[0,"serde"],[87,"serde::de"],[265,"serde::de::value"],[1531,"serde::ser"],[1642,"core::result"],[1643,"core::iter::traits::collect"],[1644,"core::marker"],[1645,"core::fmt"],[1646,"core::option"],[1647,"serde::de::ignored_any"],[1648,"alloc::string"],[1649,"core::any"],[1650,"alloc::vec"],[1651,"core::iter::traits::iterator"],[1652,"core::clone"],[1653,"alloc::borrow"],[1654,"serde::ser::impossible"],[1655,"serde_derive"]],"i":[0,0,0,27,10,10,0,0,10,10,10,10,10,10,10,0,10,10,10,0,26,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,0,27,10,0,20,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,49,49,49,0,0,0,0,58,49,0,0,27,60,61,65,59,0,49,0,0,49,0,49,49,49,49,49,0,49,0,49,49,49,0,49,49,49,52,29,65,0,0,48,49,48,49,48,49,48,49,28,48,26,52,48,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,28,48,49,29,48,55,55,48,48,49,49,48,49,48,49,58,28,28,28,27,28,59,59,60,60,61,61,61,61,61,61,60,61,59,48,49,49,48,49,48,49,59,48,49,59,28,28,0,65,65,29,48,29,29,29,29,48,29,29,48,29,29,48,29,48,29,29,29,48,29,29,48,29,48,29,48,29,48,29,48,29,48,29,29,48,29,29,29,48,29,29,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,78,78,78,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,75,94,78,67,68,69,70,71,72,73,74,75,78,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,75,94,75,75,75,75,75,94,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,78,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,68,69,70,71,72,96,0,10,13,14,15,16,17,18,19,0,10,13,14,15,16,17,18,19,0,0,10,0,10,0,10,0,10,0,10,0,10,0,10,0,0,101,101,10,10,10,12,13,14,15,16,17,18,19,101,101,101,101,101,101,101,101,101,10,20,10,10,10,13,14,101,101,17,10,10,15,16,18,19,101,101,101,101,10,10,10,10,10,17,101,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,17,101,18,19,101,101,101],"f":"````````````````{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ai}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}BhBh{{Bn{}{{Bj{{Bl{AeAg}}}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}Bn}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Cb}}`{c{{Af{Cd}}}Cf}{{{Cf{}{{d{c}}}}e}{{Af{c}}}ChCj}0000{{{Cf{}{{d{c}}}}Cl{Cn{Cl}}e}{{Af{c}}}ChCj}1111111111{{{Cf{}{{d{c}}}}Cle}{{Af{c}}}ChCj}22221{{{Cf{}{{d{c}}}}D`e}{{Af{c}}}ChCj}{{{Cf{}{{d{c}}}}ClD`e}{{Af{c}}}ChCj}4444442`{{{Cf{}{{d{c}}}}}DbCh}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}}Db{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}`{{Bhc}AfAd}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Db}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Cn{Dd}}}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Df}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dh}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dj}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dn}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}E`}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Eb}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ed}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Ef{D`}}}{{Af{oe}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClAe}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClAe}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Ef{D`}}}{{Af{ge}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Cl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClD`}{{Af{Aae}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClD`}{{Af{Ace}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}D`}{{Af{ie}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClD`}{{Af{ke}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClD`}{{Af{me}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ej}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}El}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Eh}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}En}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dd}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}=:{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhCl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}``````````````````````````````````````````{ce{}{}}000{F`F`}{FbFb}{{ce}Fd{}{}}0{cChCb}{{}F`}{c{{Af{Cd}}}Cf}{{{Fh{}{{Ff{c}}}}e}{{Af{c}}}{}Cf}{c{{Af{F`}}}Cf}{{{Cf{}{{d{c}}}}e}{{Af{c}}}ChCj}0000{{{Cf{}{{d{c}}}}Cl{Cn{Cl}}e}{{Af{c}}}ChCj}1111111111{{{Cf{}{{d{c}}}}Cle}{{Af{c}}}ChCj}22221{{{Cf{}{{d{c}}}}D`e}{{Af{c}}}ChCj}{{{Cf{}{{d{c}}}}ClD`e}{{Af{c}}}ChCj}4444442{ClCh}{{F`F`}Db}{{FbFb}Db}{{{Cj{}{{Ff{c}}}}Fj}Fl{}}{{F`Fj}Fl}{{FnFj}Fl}01{{cFj}{{Af{FdG`}}}{}}{{FbFj}Fl}0{cc{}}0{ce{}{}}0{{{Gd{}{{Gb{c}}}}}c{{Cf{}{{d{e}}}}}Ch}{{D`Fn}Ch}{{FbFn}Ch}0{{{Cf{}{{d{c}}}}}DbCh}={{{Gf{}{{d{c}}}}}{{Af{ec}}}ChCd}{{{Gf{}{{d{c}}}}e}{{Af{c}}}ChFh}{{{Gh{}{{d{c}}}}}{{Af{{Ef{e}}c}}}ChCd}{{{Gh{}{{d{c}}}}e}{{Af{Efc}}}ChFh}{{{Gj{}{{d{c}}}}}{{Af{{Ef{{Bl{eg}}}}c}}}ChCdCd}{{{Gj{}{{d{c}}}}eg}{{Af{{Ef{Bl}}c}}}ChFhFh}{{{Gj{}{{d{c}}}}}{{Af{{Ef{e}}c}}}ChCd}{{{Gj{}{{d{c}}}}e}{{Af{Efc}}}ChFh}{{{Gj{}{{d{c}}}}}{{Af{ec}}}ChCd}{{{Gj{}{{d{c}}}}e}{{Af{c}}}ChFh}{{{Gh{}{{d{c}}}}}{{Ef{D`}}}Ch}{{{Gj{}{{d{c}}}}}{{Ef{D`}}}Ch}{{{Gf{}{{d{c}}}}{Cn{Cl}}e}{{Af{c}}}ChCj}{ce{}{}}0{cGl{}}{c{{Af{e}}}{}{}}000{{{Gf{}{{d{c}}}}D`e}{{Af{c}}}ChCj}{cGn{}}0{{{Gf{}{{d{c}}}}}{{Af{Fdc}}}Ch}{{Cl{Cn{Cl}}}Ch}0`{{{Hb{}{{d{c}}{H`{e}}}}}{{Af{{Bl{ge}}c}}}Ch{{Gf{}{{d{c}}}}}Cd}{{{Hb{}{{d{c}}{H`{e}}}}g}{{Af{{Bl{e}}c}}}Ch{{Gf{}{{d{c}}}}}Fh}{{{Cj{}{{Ff{c}}}}Db}{{Af{ce}}}{}Ch}{{F`Db}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}{Cn{Dd}}}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Cl}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}{Hd{Dd}}}{{Af{ce}}}{}Ch}2{{F`{Cn{Dd}}}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Df}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}e}{{Af{c}}}{}Hb}{{F`c}{{Af{e}}}Hb{}}{{{Cj{}{{Ff{c}}}}Dh}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Dj}{{Af{ce}}}{}Ch}{{F`Dj}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}Dl}{{Af{ce}}}{}Ch}{{F`Dl}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}Dn}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}E`}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Eb}{{Af{ce}}}{}Ch}{{F`Eb}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}Ed}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}e}{{Af{c}}}{}Gj}{{F`c}{{Af{e}}}Gj{}}{{{Cj{}{{Ff{c}}}}e}{{Af{c}}}{}Cf}{{F`c}{{Af{e}}}Cf{}}{{{Cj{}{{Ff{c}}}}}{{Af{ce}}}{}Ch}{F`{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}e}{{Af{c}}}{}Gh}{{F`c}{{Af{e}}}Gh{}}54{{{Cj{}{{Ff{c}}}}Cl}{{Af{ce}}}{}Ch}{{F`Cl}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Gl}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Ej}{{Af{ce}}}{}Ch}{{F`Ej}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}El}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Eh}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}En}{{Af{ce}}}{}Ch}{{F`En}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}Dd}{{Af{ce}}}{}Ch}=<`````````````````````````````{ce{}{}}000000000000000000000000000000000000000000000000000000000{{{Hf{c}}}{{Hf{c}}}{}}{{{Hh{c}}}{{Hh{c}}}{}}{{{Hj{c}}}{{Hj{c}}}{}}{{{Hl{c}}}{{Hl{c}}}{}}{{{Hn{c}}}{{Hn{c}}}{}}{{{I`{c}}}{{I`{c}}}{}}{{{Ib{c}}}{{Ib{c}}}{}}{{{Id{c}}}{{Id{c}}}{}}{{{If{ce}}}{{If{ce}}}{IhIj}{}}{IlIl}{{{In{c}}}{{In{c}}}{}}{{{J`{c}}}{{J`{c}}}{}}{{{Jb{c}}}{{Jb{c}}}{}}{{{Jd{c}}}{{Jd{c}}}{}}{{{Jf{c}}}{{Jf{c}}}{}}{{{Jh{c}}}{{Jh{c}}}{}}{{{Jj{c}}}{{Jj{c}}}{}}{{{Jl{c}}}{{Jl{c}}}{}}{{{Jn{c}}}{{Jn{c}}}{}}{{{K`{c}}}{{K`{c}}}{}}{{{Kb{c}}}{{Kb{c}}}{}}{{{Kd{c}}}{{Kd{c}}}{}}{{{Kf{c}}}{{Kf{c}}}{}}{{{Kh{c}}}{{Kh{c}}}{}}{{{Kj{c}}}{{Kj{c}}}{}}{{{Kl{ce}}}{{Kl{ce}}}IjIj}{{{Kn{c}}}{{Kn{c}}}Ij}{{{L`{c}}}{{L`{c}}}Ij}{{{Lb{c}}}{{Lb{c}}}Ij}{{ce}Fd{}{}}0000000000000000000000000000{cIlCb}0{IlCl}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{I`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Id{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{If{ce}}Cl{Cn{Cl}}g}{{Af{i}}}IhChCj{}}{{{In{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{J`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{K`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}Cl{Cn{Cl}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}Cl{Cn{Cl}}e}{{Af{g}}}GhCj{}}{{{L`{c}}Cl{Cn{Cl}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}Cl{Cn{Cl}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}Cle}{{Af{g}}}ChCj{}}{{{Hh{c}}Cle}{{Af{g}}}ChCj{}}{{{Hj{c}}Cle}{{Af{g}}}ChCj{}}{{{Hl{c}}Cle}{{Af{g}}}ChCj{}}{{{Hn{c}}Cle}{{Af{g}}}ChCj{}}{{{I`{c}}Cle}{{Af{g}}}ChCj{}}{{{Ib{c}}Cle}{{Af{g}}}ChCj{}}{{{Id{c}}Cle}{{Af{g}}}ChCj{}}{{{If{ce}}Clg}{{Af{i}}}IhChCj{}}{{{In{c}}Cle}{{Af{g}}}ChCj{}}{{{J`{c}}Cle}{{Af{g}}}ChCj{}}{{{Jb{c}}Cle}{{Af{g}}}ChCj{}}{{{Jd{c}}Cle}{{Af{g}}}ChCj{}}{{{Jf{c}}Cle}{{Af{g}}}ChCj{}}{{{Jh{c}}Cle}{{Af{g}}}ChCj{}}{{{Jj{c}}Cle}{{Af{g}}}ChCj{}}{{{Jl{c}}Cle}{{Af{g}}}ChCj{}}{{{Jn{c}}Cle}{{Af{g}}}ChCj{}}{{{K`{c}}Cle}{{Af{g}}}ChCj{}}{{{Kb{c}}Cle}{{Af{g}}}ChCj{}}{{{Kd{c}}Cle}{{Af{g}}}ChCj{}}{{{Kf{c}}Cle}{{Af{g}}}ChCj{}}{{{Kh{c}}Cle}{{Af{g}}}ChCj{}}{{{Kj{c}}Cle}{{Af{g}}}ChCj{}}{{{Kl{gc}}Cli}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}Cle}{{Af{g}}}GhCj{}}{{{L`{c}}Cle}{{Af{g}}}GjCj{}}{{{Lb{c}}Cle}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{I`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Id{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{If{ce}}Cl{Cn{Cl}}g}{{Af{i}}}IhChCj{}}{{{In{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{J`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{K`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}Cl{Cn{Cl}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}Cl{Cn{Cl}}e}{{Af{g}}}GhCj{}}{{{L`{c}}Cl{Cn{Cl}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}Cl{Cn{Cl}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}D`e}{{Af{g}}}ChCj{}}{{{Hh{c}}D`e}{{Af{g}}}ChCj{}}{{{Hj{c}}D`e}{{Af{g}}}ChCj{}}{{{Hl{c}}D`e}{{Af{g}}}ChCj{}}{{{Hn{c}}D`e}{{Af{g}}}ChCj{}}{{{I`{c}}D`e}{{Af{g}}}ChCj{}}{{{Ib{c}}D`e}{{Af{g}}}ChCj{}}{{{Id{c}}D`e}{{Af{g}}}ChCj{}}{{{If{ce}}D`g}{{Af{i}}}IhChCj{}}{{{In{c}}D`e}{{Af{g}}}ChCj{}}{{{J`{c}}D`e}{{Af{g}}}ChCj{}}{{{Jb{c}}D`e}{{Af{g}}}ChCj{}}{{{Jd{c}}D`e}{{Af{g}}}ChCj{}}{{{Jf{c}}D`e}{{Af{g}}}ChCj{}}{{{Jh{c}}D`e}{{Af{g}}}ChCj{}}{{{Jj{c}}D`e}{{Af{g}}}ChCj{}}{{{Jl{c}}D`e}{{Af{g}}}ChCj{}}{{{Jn{c}}D`e}{{Af{g}}}ChCj{}}{{{K`{c}}D`e}{{Af{g}}}ChCj{}}{{{Kb{c}}D`e}{{Af{g}}}ChCj{}}{{{Kd{c}}D`e}{{Af{g}}}ChCj{}}{{{Kf{c}}D`e}{{Af{g}}}ChCj{}}{{{Kh{c}}D`e}{{Af{g}}}ChCj{}}{{{Kj{c}}D`e}{{Af{g}}}ChCj{}}{{{Kl{gc}}D`i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}D`e}{{Af{g}}}GhCj{}}{{{L`{c}}D`e}{{Af{g}}}GjCj{}}{{{Lb{c}}D`e}{{Af{g}}}HbCj{}}{{{Hf{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Hh{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Hj{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Hl{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Hn{c}}ClD`e}{{Af{g}}}ChCj{}}{{{I`{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Ib{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Id{c}}ClD`e}{{Af{g}}}ChCj{}}{{{If{ce}}ClD`g}{{Af{i}}}IhChCj{}}{{{In{c}}ClD`e}{{Af{g}}}ChCj{}}{{{J`{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jb{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jd{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jf{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jh{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jj{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jl{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jn{c}}ClD`e}{{Af{g}}}ChCj{}}{{{K`{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kb{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kd{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kf{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kh{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kj{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kl{gc}}ClD`i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}ClD`e}{{Af{g}}}GhCj{}}{{{L`{c}}ClD`e}{{Af{g}}}GjCj{}}{{{Lb{c}}ClD`e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}Cle}{{Af{g}}}ChCj{}}{{{Hh{c}}Cle}{{Af{g}}}ChCj{}}{{{Hj{c}}Cle}{{Af{g}}}ChCj{}}{{{Hl{c}}Cle}{{Af{g}}}ChCj{}}{{{Hn{c}}Cle}{{Af{g}}}ChCj{}}{{{I`{c}}Cle}{{Af{g}}}ChCj{}}{{{Ib{c}}Cle}{{Af{g}}}ChCj{}}{{{Id{c}}Cle}{{Af{g}}}ChCj{}}{{{If{ce}}Clg}{{Af{i}}}IhChCj{}}{{{In{c}}Cle}{{Af{g}}}ChCj{}}{{{J`{c}}Cle}{{Af{g}}}ChCj{}}{{{Jb{c}}Cle}{{Af{g}}}ChCj{}}{{{Jd{c}}Cle}{{Af{g}}}ChCj{}}{{{Jf{c}}Cle}{{Af{g}}}ChCj{}}{{{Jh{c}}Cle}{{Af{g}}}ChCj{}}{{{Jj{c}}Cle}{{Af{g}}}ChCj{}}{{{Jl{c}}Cle}{{Af{g}}}ChCj{}}{{{Jn{c}}Cle}{{Af{g}}}ChCj{}}{{{K`{c}}Cle}{{Af{g}}}ChCj{}}{{{Kb{c}}Cle}{{Af{g}}}ChCj{}}{{{Kd{c}}Cle}{{Af{g}}}ChCj{}}{{{Kf{c}}Cle}{{Af{g}}}ChCj{}}{{{Kh{c}}Cle}{{Af{g}}}ChCj{}}{{{Kj{c}}Cle}{{Af{g}}}ChCj{}}{{{Kl{gc}}Cli}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}Cle}{{Af{g}}}GhCj{}}{{{L`{c}}Cle}{{Af{g}}}GjCj{}}{{{Lb{c}}Cle}{{Af{g}}}HbCj{}}{{{If{ce}}}{{Af{Fde}}}IhCh}{{{Kl{ce}}}{{Af{Fde}}}IhCh}{{IlIl}Db}{{{Hf{c}}Fj}Fl{}}{{{Hh{c}}Fj}Fl{}}{{{Hj{c}}Fj}Fl{}}{{{Hl{c}}Fj}Fl{}}{{{Hn{c}}Fj}Fl{}}{{{I`{c}}Fj}Fl{}}{{{Ib{c}}Fj}Fl{}}{{{Id{c}}Fj}Fl{}}{{{If{ce}}Fj}Fl{IhLd}{}}{{IlFj}Fl}0{{{In{c}}Fj}Fl{}}{{{J`{c}}Fj}Fl{}}{{{Jb{c}}Fj}Fl{}}{{{Jd{c}}Fj}Fl{}}{{{Jf{c}}Fj}Fl{}}{{{Jh{c}}Fj}Fl{}}{{{Jj{c}}Fj}Fl{}}{{{Jl{c}}Fj}Fl{}}{{{Jn{c}}Fj}Fl{}}{{{K`{c}}Fj}Fl{}}{{{Kb{c}}Fj}Fl{}}{{{Kd{c}}Fj}Fl{}}{{{Kf{c}}Fj}Fl{}}{{{Kh{c}}Fj}Fl{}}{{{Kj{c}}Fj}Fl{}}{{{Kl{ce}}Fj}FlLd{}}{{{Kn{c}}Fj}FlLd}{{{L`{c}}Fj}FlLd}{{{Lb{c}}Fj}FlLd}{cc{}}0000000000000000000000000000{ce{}{}}0000000000000000000000000000{{}{{Hf{c}}}{}}{Eh{{Hh{c}}}{}}{Cl{{Hj{c}}}{}}{Cl{{Hl{c}}}{}}{Gl{{Hn{c}}}{}}{{{Lf{Cl}}}{{I`{c}}}{}}{{{Cn{Dd}}}{{Ib{c}}}{}}{{{Cn{Dd}}}{{Id{c}}}{}}{c{{If{ce}}}Ih{}}{Db{{In{c}}}{}}{Ed{{J`{c}}}{}}{Dn{{Jb{c}}}{}}{E`{{Jd{c}}}{}}{Eb{{Jf{c}}}{}}{Dl{{Jh{c}}}{}}{Lh{{Jj{c}}}{}}{Dd{{Jl{c}}}{}}{El{{Jn{c}}}{}}{En{{K`{c}}}{}}{Ej{{Kb{c}}}{}}{D`{{Kd{c}}}{}}{Dh{{Kf{c}}}{}}{Dj{{Kh{c}}}{}}{Df{{Kj{c}}}{}}{c{{Kl{ce}}}Ih{}}{c{{Kn{c}}}{}}{c{{L`{c}}}{}}{c{{Lb{c}}}{}}{{{If{ce}}g}{{Af{Efi}}}IhChFh{}}{{{Kl{gc}}i}{{Af{Efk}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Fh{}}{{{If{ce}}gi}{{Af{{Ef{Bl}}k}}}IhChFhFh{}}2{{{If{ce}}g}{{Af{i}}}IhChFh{}}{{{If{ce}}}{{Ef{D`}}}IhCh}0{{{Kl{gc}}}{{Ef{D`}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}}{ce{}{}}0000000000000000000000000000{cGl{}}{c{{Af{e}}}{}{}}000000000000000000000000000000000000000000000000000000000{cGn{}}0000000000000000000000000000{{{Hh{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{Hj{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{Hl{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{Hn{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{I`{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{L`{c}}e}{{Af{{Bl{g}}i}}}GjFh{}{}}```````````````````````````````````99{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ai}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}BhBh{{Bn{}{{Bj{{Bl{AeAg}}}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}Bn}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Cb}}{cAhCb}{{{Aj{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Al{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{An{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{B`{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Bb{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Bd{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Bf{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Lj{ce}}}{{Af{ce}}}{}Ah}000000{cc{}}{ce{}{}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}}Db{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{Bhc}AfAd}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Db}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Cn{Dd}}}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Df}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Aj{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Al{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Lj{ce}}g}{{Af{Fde}}}{}Ah{C`Bh}}0{{{Bb{}{{b{c}}{d{e}}}}gi}{{Af{Fde}}}{}Ah{C`Bh}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dh}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dj}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{An{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{B`{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Bd{}{{b{c}}{d{e}}}}Clg}{{Af{Fde}}}{}Ah{C`Bh}}{{{Bf{}{{b{c}}{d{e}}}}Clg}{{Af{Fde}}}{}Ah{C`Bh}}{{{Lj{ce}}Clg}{{Af{Fde}}}{}Ah{C`Bh}}088{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dn}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}E`}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Eb}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ed}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Bb{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}>{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Ef{D`}}}{{Af{oe}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClAe}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClAe}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Ef{D`}}}{{Af{ge}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Cl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClD`}{{Af{Aae}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClD`}{{Af{Ace}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}D`}{{Af{ie}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClD`}{{Af{ke}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClD`}{{Af{me}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ej}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}El}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Eh}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}En}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dd}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}=:{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhCl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Bb{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Lj{ce}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Bd{}{{b{c}}{d{e}}}}Cl}{{Af{Fde}}}{}Ah}{{{Bf{}{{b{c}}{d{e}}}}Cl}{{Af{Fde}}}{}Ah}{c{{Af{e}}}{}{}}0{cGn{}}","D":"CCd","p":[[17,"Ok"],[17,"Error"],[17,"SerializeSeq"],[17,"SerializeTuple"],[17,"SerializeTupleStruct"],[17,"SerializeTupleVariant"],[17,"SerializeMap"],[17,"SerializeStruct"],[17,"SerializeStructVariant"],[10,"Serializer",0,1531],[6,"Result",1642],[10,"Error",1531],[10,"SerializeSeq",1531],[10,"SerializeTuple",1531],[10,"SerializeTupleStruct",1531],[10,"SerializeTupleVariant",1531],[10,"SerializeMap",1531],[10,"SerializeStruct",1531],[10,"SerializeStructVariant",1531],[10,"Serialize",0,1531],[17,"Item"],[1,"tuple"],[10,"IntoIterator",1643],[10,"Sized",1644],[10,"Display",1645],[10,"Deserialize",0,87],[10,"Deserializer",0,87],[10,"Error",87],[10,"Visitor",87],[1,"str"],[1,"slice"],[1,"usize"],[1,"bool"],[1,"u8"],[1,"char"],[1,"f32"],[1,"f64"],[1,"i128"],[1,"i16"],[1,"i32"],[1,"i64"],[1,"i8"],[6,"Option",1646],[1,"u32"],[1,"u128"],[1,"u16"],[1,"u64"],[5,"IgnoredAny",87,1647],[6,"Unexpected",87],[1,"unit"],[17,"Value"],[10,"DeserializeSeed",87],[5,"Formatter",1645],[8,"Result",1645],[10,"Expected",87],[5,"Error",1645],[17,"Deserializer"],[10,"IntoDeserializer",87],[10,"VariantAccess",87],[10,"SeqAccess",87],[10,"MapAccess",87],[5,"String",1648],[5,"TypeId",1649],[17,"Variant"],[10,"EnumAccess",87],[5,"Vec",1650],[5,"UnitDeserializer",265],[5,"U32Deserializer",265],[5,"StrDeserializer",265],[5,"BorrowedStrDeserializer",265],[5,"StringDeserializer",265],[5,"CowStrDeserializer",265],[5,"BytesDeserializer",265],[5,"BorrowedBytesDeserializer",265],[5,"MapDeserializer",265],[10,"Iterator",1651],[10,"Clone",1652],[5,"Error",265],[5,"BoolDeserializer",265],[5,"I8Deserializer",265],[5,"I16Deserializer",265],[5,"I32Deserializer",265],[5,"I64Deserializer",265],[5,"I128Deserializer",265],[5,"IsizeDeserializer",265],[5,"U8Deserializer",265],[5,"U16Deserializer",265],[5,"U64Deserializer",265],[5,"U128Deserializer",265],[5,"UsizeDeserializer",265],[5,"F32Deserializer",265],[5,"F64Deserializer",265],[5,"CharDeserializer",265],[5,"SeqDeserializer",265],[5,"SeqAccessDeserializer",265],[5,"MapAccessDeserializer",265],[5,"EnumAccessDeserializer",265],[10,"Debug",1645],[6,"Cow",1653],[1,"isize"],[5,"Impossible",1531,1654]],"r":[[0,87],[1,1655],[2,87],[6,1531],[7,1655],[15,1531],[105,1647],[1540,1654]],"b":[[182,"impl-Debug-for-Unexpected%3C\'a%3E"],[183,"impl-Display-for-Unexpected%3C\'a%3E"],[410,"impl-Error-for-Error"],[411,"impl-Error-for-Error"],[1293,"impl-Debug-for-Error"],[1294,"impl-Display-for-Error"],[1405,"impl-MapAccess%3C\'de%3E-for-MapDeserializer%3C\'de,+I,+E%3E"],[1406,"impl-SeqAccess%3C\'de%3E-for-MapDeserializer%3C\'de,+I,+E%3E"],[1579,"impl-SerializeTupleStruct-for-Impossible%3COk,+Error%3E"],[1580,"impl-SerializeStruct-for-Impossible%3COk,+Error%3E"],[1581,"impl-SerializeTuple-for-Impossible%3COk,+Error%3E"],[1582,"impl-SerializeTupleVariant-for-Impossible%3COk,+Error%3E"],[1583,"impl-SerializeStructVariant-for-Impossible%3COk,+Error%3E"],[1584,"impl-SerializeSeq-for-Impossible%3COk,+Error%3E"],[1585,"impl-SerializeMap-for-Impossible%3COk,+Error%3E"],[1595,"impl-SerializeTuple-for-Impossible%3COk,+Error%3E"],[1596,"impl-SerializeSeq-for-Impossible%3COk,+Error%3E"],[1604,"impl-SerializeStruct-for-Impossible%3COk,+Error%3E"],[1605,"impl-SerializeStructVariant-for-Impossible%3COk,+Error%3E"],[1606,"impl-SerializeTupleStruct-for-Impossible%3COk,+Error%3E"],[1607,"impl-SerializeTupleVariant-for-Impossible%3COk,+Error%3E"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAANAEJQB1AAAAggAHAIsAAACOAAAArwABALIAAAC0AAQA0AAGANgAAQDhAAAA5gAAAOkAAADsAAAA7gAAAPIAAAD1AAAA9wAAAPkAAAD7AAAA/QAAAP8AAAACAQAABgEAAAkBAAAnAdoDBAUeAF0FAgBhBQEAZgUOAHkFggAeBgIALAYGADwGAQBFBgMATwYAAGUGAABoBgIA"}],\ +["serde",{"t":"KYKRRRKYRRRRRRRKNNNCMMMMMMMMMNMMMMMMMMMMMMMMMNMMMMMMQNNCMMMMMMNMMMMMMMMMMMMMMMMNMMMMMMMPPPKKKKRPKKRRRRRKPFKPKPPPPPKPEPPPGPPPRRRKKNNNNNNNNMNMMNMMMMMMMMNMMMMMMMMMMMMMMMNMMMMMMNNNMNMNNNNNNNNNMNNNNNNMNMNNNMNMNNMNNNNNNNMNNMNNCNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFFFFFFFFFFFFFFFFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKRRRRRRRRFRRRRRRRRKKRKRKRKRKRKRKRKENNNNNMMMMMMMMNNNNNNNNNNMMMMMMNNNMMMMMMNNNNNMMMMMNMMMMMMMMMMMMNMMMMMMMMNNNNNN","n":["Deserialize","Deserialize","Deserializer","Error","Error","Ok","Serialize","Serialize","SerializeMap","SerializeSeq","SerializeStruct","SerializeStructVariant","SerializeTuple","SerializeTupleStruct","SerializeTupleVariant","Serializer","collect_map","collect_seq","collect_str","de","deserialize","deserialize_any","deserialize_bool","deserialize_byte_buf","deserialize_bytes","deserialize_char","deserialize_enum","deserialize_f32","deserialize_f64","deserialize_i128","deserialize_i16","deserialize_i32","deserialize_i64","deserialize_i8","deserialize_identifier","deserialize_ignored_any","deserialize_map","deserialize_newtype_struct","deserialize_option","deserialize_seq","deserialize_str","deserialize_string","deserialize_struct","deserialize_tuple","deserialize_tuple_struct","deserialize_u128","deserialize_u16","deserialize_u32","deserialize_u64","deserialize_u8","deserialize_unit","deserialize_unit_struct","forward_to_deserialize_any","is_human_readable","is_human_readable","ser","serialize","serialize_bool","serialize_bytes","serialize_char","serialize_f32","serialize_f64","serialize_i128","serialize_i16","serialize_i32","serialize_i64","serialize_i8","serialize_map","serialize_newtype_struct","serialize_newtype_variant","serialize_none","serialize_seq","serialize_some","serialize_str","serialize_struct","serialize_struct_variant","serialize_tuple","serialize_tuple_struct","serialize_tuple_variant","serialize_u128","serialize_u16","serialize_u32","serialize_u64","serialize_u8","serialize_unit","serialize_unit_struct","serialize_unit_variant","Bool","Bytes","Char","Deserialize","DeserializeOwned","DeserializeSeed","Deserializer","Deserializer","Enum","EnumAccess","Error","Error","Error","Error","Error","Error","Expected","Float","IgnoredAny","IntoDeserializer","Map","MapAccess","NewtypeStruct","NewtypeVariant","Option","Other","Seq","SeqAccess","Signed","StdError","Str","StructVariant","TupleVariant","Unexpected","Unit","UnitVariant","Unsigned","Value","Value","Variant","VariantAccess","Visitor","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","custom","default","deserialize","deserialize","deserialize","deserialize_any","deserialize_bool","deserialize_byte_buf","deserialize_bytes","deserialize_char","deserialize_enum","deserialize_f32","deserialize_f64","deserialize_i128","deserialize_i16","deserialize_i32","deserialize_i64","deserialize_i8","deserialize_identifier","deserialize_ignored_any","deserialize_map","deserialize_newtype_struct","deserialize_option","deserialize_seq","deserialize_str","deserialize_string","deserialize_struct","deserialize_tuple","deserialize_tuple_struct","deserialize_u128","deserialize_u16","deserialize_u32","deserialize_u64","deserialize_u8","deserialize_unit","deserialize_unit_struct","duplicate_field","eq","eq","expecting","expecting","fmt","fmt","fmt","fmt","fmt","fmt","from","from","into","into","into_deserializer","invalid_length","invalid_type","invalid_value","is_human_readable","missing_field","newtype_variant","newtype_variant_seed","next_element","next_element_seed","next_entry","next_entry_seed","next_key","next_key_seed","next_value","next_value_seed","size_hint","size_hint","struct_variant","to_owned","to_owned","to_string","try_from","try_from","try_into","try_into","tuple_variant","type_id","type_id","unit_variant","unknown_field","unknown_variant","value","variant","variant_seed","visit_bool","visit_bool","visit_borrowed_bytes","visit_borrowed_str","visit_byte_buf","visit_bytes","visit_bytes","visit_char","visit_enum","visit_enum","visit_f32","visit_f64","visit_f64","visit_i128","visit_i128","visit_i16","visit_i32","visit_i64","visit_i64","visit_i8","visit_map","visit_map","visit_newtype_struct","visit_newtype_struct","visit_none","visit_none","visit_seq","visit_seq","visit_some","visit_some","visit_str","visit_str","visit_string","visit_u128","visit_u128","visit_u16","visit_u32","visit_u64","visit_u64","visit_u8","visit_unit","visit_unit","BoolDeserializer","BorrowedBytesDeserializer","BorrowedStrDeserializer","BytesDeserializer","CharDeserializer","CowStrDeserializer","EnumAccessDeserializer","Error","F32Deserializer","F64Deserializer","I128Deserializer","I16Deserializer","I32Deserializer","I64Deserializer","I8Deserializer","IsizeDeserializer","MapAccessDeserializer","MapDeserializer","SeqAccessDeserializer","SeqDeserializer","StrDeserializer","StringDeserializer","U128Deserializer","U16Deserializer","U32Deserializer","U64Deserializer","U8Deserializer","UnitDeserializer","UsizeDeserializer","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","custom","custom","description","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_any","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_char","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_map","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_option","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_str","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_string","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","end","end","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","new","next_element_seed","next_element_seed","next_entry_seed","next_key_seed","next_value_seed","size_hint","size_hint","size_hint","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","variant_seed","variant_seed","variant_seed","variant_seed","variant_seed","variant_seed","Error","Error","Error","Error","Error","Error","Error","Error","Error","Impossible","Ok","Ok","Ok","Ok","Ok","Ok","Ok","Ok","Serialize","SerializeMap","SerializeMap","SerializeSeq","SerializeSeq","SerializeStruct","SerializeStruct","SerializeStructVariant","SerializeStructVariant","SerializeTuple","SerializeTuple","SerializeTupleStruct","SerializeTupleStruct","SerializeTupleVariant","SerializeTupleVariant","Serializer","StdError","borrow","borrow_mut","collect_map","collect_seq","collect_str","custom","end","end","end","end","end","end","end","end","end","end","end","end","end","end","from","into","is_human_readable","serialize","serialize_bool","serialize_bytes","serialize_char","serialize_element","serialize_element","serialize_element","serialize_element","serialize_entry","serialize_f32","serialize_f64","serialize_field","serialize_field","serialize_field","serialize_field","serialize_field","serialize_field","serialize_field","serialize_field","serialize_i128","serialize_i16","serialize_i32","serialize_i64","serialize_i8","serialize_key","serialize_key","serialize_map","serialize_newtype_struct","serialize_newtype_variant","serialize_none","serialize_seq","serialize_some","serialize_str","serialize_struct","serialize_struct_variant","serialize_tuple","serialize_tuple_struct","serialize_tuple_variant","serialize_u128","serialize_u16","serialize_u32","serialize_u64","serialize_u8","serialize_unit","serialize_unit_struct","serialize_unit_variant","serialize_value","serialize_value","skip_field","skip_field","try_from","try_into","type_id"],"q":[[0,"serde"],[87,"serde::de"],[265,"serde::de::value"],[1531,"serde::ser"],[1642,"core::result"],[1643,"core::iter::traits::collect"],[1644,"core::marker"],[1645,"core::fmt"],[1646,"core::option"],[1647,"serde::de::ignored_any"],[1648,"alloc::string"],[1649,"core::any"],[1650,"alloc::vec"],[1651,"core::iter::traits::iterator"],[1652,"core::clone"],[1653,"alloc::borrow"],[1654,"serde::ser::impossible"],[1655,"serde_derive"]],"i":[0,0,0,27,10,10,0,0,10,10,10,10,10,10,10,0,10,10,10,0,26,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,0,27,10,0,20,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,49,49,49,0,0,0,0,58,49,0,0,27,60,61,65,59,0,49,0,0,49,0,49,49,49,49,49,0,49,0,49,49,49,0,49,49,49,52,29,65,0,0,48,49,48,49,48,49,48,49,28,48,26,52,48,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,28,48,49,29,48,55,55,48,48,49,49,48,49,48,49,58,28,28,28,27,28,59,59,60,60,61,61,61,61,61,61,60,61,59,48,49,49,48,49,48,49,59,48,49,59,28,28,0,65,65,29,48,29,29,29,29,48,29,29,48,29,29,48,29,48,29,29,29,48,29,29,48,29,48,29,48,29,48,29,48,29,48,29,29,48,29,29,29,48,29,29,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,78,78,78,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,75,94,78,67,68,69,70,71,72,73,74,75,78,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,75,94,75,75,75,75,75,94,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,78,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,67,68,69,70,71,72,73,74,75,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,68,69,70,71,72,96,0,10,13,14,15,16,17,18,19,0,10,13,14,15,16,17,18,19,0,0,10,0,10,0,10,0,10,0,10,0,10,0,10,0,0,101,101,10,10,10,12,13,14,15,16,17,18,19,101,101,101,101,101,101,101,101,101,10,20,10,10,10,13,14,101,101,17,10,10,15,16,18,19,101,101,101,101,10,10,10,10,10,17,101,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,17,101,18,19,101,101,101],"f":"````````````````{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ai}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}BhBh{{Bn{}{{Bj{{Bl{AeAg}}}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}Bn}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Cb}}`{c{{Af{Cd}}}Cf}{{{Cf{}{{d{c}}}}e}{{Af{c}}}ChCj}0000{{{Cf{}{{d{c}}}}Cl{Cn{Cl}}e}{{Af{c}}}ChCj}1111111111{{{Cf{}{{d{c}}}}Cle}{{Af{c}}}ChCj}22221{{{Cf{}{{d{c}}}}D`e}{{Af{c}}}ChCj}{{{Cf{}{{d{c}}}}ClD`e}{{Af{c}}}ChCj}4444442`{{{Cf{}{{d{c}}}}}DbCh}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}}Db{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}`{{Bhc}AfAd}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Db}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Cn{Dd}}}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Df}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dh}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dj}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dn}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}E`}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Eb}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ed}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Ef{D`}}}{{Af{oe}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClAe}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClAe}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Ef{D`}}}{{Af{ge}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Cl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClD`}{{Af{Aae}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClD`}{{Af{Ace}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}D`}{{Af{ie}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClD`}{{Af{ke}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClD`}{{Af{me}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ej}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}El}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Eh}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}En}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dd}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}=:{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhCl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}``````````````````````````````````````````{ce{}{}}000{F`F`}{FbFb}{{ce}Fd{}{}}0{cChCb}{{}F`}{c{{Af{Cd}}}Cf}{{{Fh{}{{Ff{c}}}}e}{{Af{c}}}{}Cf}{c{{Af{F`}}}Cf}{{{Cf{}{{d{c}}}}e}{{Af{c}}}ChCj}0000{{{Cf{}{{d{c}}}}Cl{Cn{Cl}}e}{{Af{c}}}ChCj}1111111111{{{Cf{}{{d{c}}}}Cle}{{Af{c}}}ChCj}22221{{{Cf{}{{d{c}}}}D`e}{{Af{c}}}ChCj}{{{Cf{}{{d{c}}}}ClD`e}{{Af{c}}}ChCj}4444442{ClCh}{{F`F`}Db}{{FbFb}Db}{{{Cj{}{{Ff{c}}}}Fj}Fl{}}{{F`Fj}Fl}{{FnFj}Fl}0{{cFj}{{Af{FdG`}}}{}}2{{FbFj}Fl}0{cc{}}0{ce{}{}}0{{{Gd{}{{Gb{c}}}}}c{{Cf{}{{d{e}}}}}Ch}{{D`Fn}Ch}{{FbFn}Ch}0{{{Cf{}{{d{c}}}}}DbCh}={{{Gf{}{{d{c}}}}}{{Af{ec}}}ChCd}{{{Gf{}{{d{c}}}}e}{{Af{c}}}ChFh}{{{Gh{}{{d{c}}}}}{{Af{{Ef{e}}c}}}ChCd}{{{Gh{}{{d{c}}}}e}{{Af{Efc}}}ChFh}{{{Gj{}{{d{c}}}}}{{Af{{Ef{{Bl{eg}}}}c}}}ChCdCd}{{{Gj{}{{d{c}}}}eg}{{Af{{Ef{Bl}}c}}}ChFhFh}{{{Gj{}{{d{c}}}}}{{Af{{Ef{e}}c}}}ChCd}{{{Gj{}{{d{c}}}}e}{{Af{Efc}}}ChFh}{{{Gj{}{{d{c}}}}}{{Af{ec}}}ChCd}{{{Gj{}{{d{c}}}}e}{{Af{c}}}ChFh}{{{Gh{}{{d{c}}}}}{{Ef{D`}}}Ch}{{{Gj{}{{d{c}}}}}{{Ef{D`}}}Ch}{{{Gf{}{{d{c}}}}{Cn{Cl}}e}{{Af{c}}}ChCj}{ce{}{}}0{cGl{}}{c{{Af{e}}}{}{}}000{{{Gf{}{{d{c}}}}D`e}{{Af{c}}}ChCj}{cGn{}}0{{{Gf{}{{d{c}}}}}{{Af{Fdc}}}Ch}{{Cl{Cn{Cl}}}Ch}0`{{{Hb{}{{d{c}}{H`{e}}}}}{{Af{{Bl{ge}}c}}}Ch{{Gf{}{{d{c}}}}}Cd}{{{Hb{}{{d{c}}{H`{e}}}}g}{{Af{{Bl{e}}c}}}Ch{{Gf{}{{d{c}}}}}Fh}{{{Cj{}{{Ff{c}}}}Db}{{Af{ce}}}{}Ch}{{F`Db}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}{Cn{Dd}}}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Cl}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}{Hd{Dd}}}{{Af{ce}}}{}Ch}2{{F`{Cn{Dd}}}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Df}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}e}{{Af{c}}}{}Hb}{{F`c}{{Af{e}}}Hb{}}{{{Cj{}{{Ff{c}}}}Dh}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Dj}{{Af{ce}}}{}Ch}{{F`Dj}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}Dl}{{Af{ce}}}{}Ch}{{F`Dl}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}Dn}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}E`}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Eb}{{Af{ce}}}{}Ch}{{F`Eb}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}Ed}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}e}{{Af{c}}}{}Gj}{{F`c}{{Af{e}}}Gj{}}{{{Cj{}{{Ff{c}}}}e}{{Af{c}}}{}Cf}{{F`c}{{Af{e}}}Cf{}}{{{Cj{}{{Ff{c}}}}}{{Af{ce}}}{}Ch}{F`{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}e}{{Af{c}}}{}Gh}{{F`c}{{Af{e}}}Gh{}}54{{{Cj{}{{Ff{c}}}}Cl}{{Af{ce}}}{}Ch}{{F`Cl}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Gl}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Ej}{{Af{ce}}}{}Ch}{{F`Ej}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}El}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}Eh}{{Af{ce}}}{}Ch}{{{Cj{}{{Ff{c}}}}En}{{Af{ce}}}{}Ch}{{F`En}{{Af{ce}}}{}{}}{{{Cj{}{{Ff{c}}}}Dd}{{Af{ce}}}{}Ch}=<`````````````````````````````{ce{}{}}000000000000000000000000000000000000000000000000000000000{{{Hf{c}}}{{Hf{c}}}{}}{{{Hh{c}}}{{Hh{c}}}{}}{{{Hj{c}}}{{Hj{c}}}{}}{{{Hl{c}}}{{Hl{c}}}{}}{{{Hn{c}}}{{Hn{c}}}{}}{{{I`{c}}}{{I`{c}}}{}}{{{Ib{c}}}{{Ib{c}}}{}}{{{Id{c}}}{{Id{c}}}{}}{{{If{ce}}}{{If{ce}}}{IhIj}{}}{IlIl}{{{In{c}}}{{In{c}}}{}}{{{J`{c}}}{{J`{c}}}{}}{{{Jb{c}}}{{Jb{c}}}{}}{{{Jd{c}}}{{Jd{c}}}{}}{{{Jf{c}}}{{Jf{c}}}{}}{{{Jh{c}}}{{Jh{c}}}{}}{{{Jj{c}}}{{Jj{c}}}{}}{{{Jl{c}}}{{Jl{c}}}{}}{{{Jn{c}}}{{Jn{c}}}{}}{{{K`{c}}}{{K`{c}}}{}}{{{Kb{c}}}{{Kb{c}}}{}}{{{Kd{c}}}{{Kd{c}}}{}}{{{Kf{c}}}{{Kf{c}}}{}}{{{Kh{c}}}{{Kh{c}}}{}}{{{Kj{c}}}{{Kj{c}}}{}}{{{Kl{ce}}}{{Kl{ce}}}IjIj}{{{Kn{c}}}{{Kn{c}}}Ij}{{{L`{c}}}{{L`{c}}}Ij}{{{Lb{c}}}{{Lb{c}}}Ij}{{ce}Fd{}{}}0000000000000000000000000000{cIlCb}0{IlCl}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{I`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Id{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{If{ce}}Cl{Cn{Cl}}g}{{Af{i}}}IhChCj{}}{{{In{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{J`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{K`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}Cl{Cn{Cl}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}Cl{Cn{Cl}}e}{{Af{g}}}GhCj{}}{{{L`{c}}Cl{Cn{Cl}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}Cl{Cn{Cl}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}Cle}{{Af{g}}}ChCj{}}{{{Hh{c}}Cle}{{Af{g}}}ChCj{}}{{{Hj{c}}Cle}{{Af{g}}}ChCj{}}{{{Hl{c}}Cle}{{Af{g}}}ChCj{}}{{{Hn{c}}Cle}{{Af{g}}}ChCj{}}{{{I`{c}}Cle}{{Af{g}}}ChCj{}}{{{Ib{c}}Cle}{{Af{g}}}ChCj{}}{{{Id{c}}Cle}{{Af{g}}}ChCj{}}{{{If{ce}}Clg}{{Af{i}}}IhChCj{}}{{{In{c}}Cle}{{Af{g}}}ChCj{}}{{{J`{c}}Cle}{{Af{g}}}ChCj{}}{{{Jb{c}}Cle}{{Af{g}}}ChCj{}}{{{Jd{c}}Cle}{{Af{g}}}ChCj{}}{{{Jf{c}}Cle}{{Af{g}}}ChCj{}}{{{Jh{c}}Cle}{{Af{g}}}ChCj{}}{{{Jj{c}}Cle}{{Af{g}}}ChCj{}}{{{Jl{c}}Cle}{{Af{g}}}ChCj{}}{{{Jn{c}}Cle}{{Af{g}}}ChCj{}}{{{K`{c}}Cle}{{Af{g}}}ChCj{}}{{{Kb{c}}Cle}{{Af{g}}}ChCj{}}{{{Kd{c}}Cle}{{Af{g}}}ChCj{}}{{{Kf{c}}Cle}{{Af{g}}}ChCj{}}{{{Kh{c}}Cle}{{Af{g}}}ChCj{}}{{{Kj{c}}Cle}{{Af{g}}}ChCj{}}{{{Kl{gc}}Cli}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}Cle}{{Af{g}}}GhCj{}}{{{L`{c}}Cle}{{Af{g}}}GjCj{}}{{{Lb{c}}Cle}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{I`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Id{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{If{ce}}Cl{Cn{Cl}}g}{{Af{i}}}IhChCj{}}{{{In{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{J`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{K`{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}Cl{Cn{Cl}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}Cl{Cn{Cl}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}Cl{Cn{Cl}}e}{{Af{g}}}GhCj{}}{{{L`{c}}Cl{Cn{Cl}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}Cl{Cn{Cl}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}D`e}{{Af{g}}}ChCj{}}{{{Hh{c}}D`e}{{Af{g}}}ChCj{}}{{{Hj{c}}D`e}{{Af{g}}}ChCj{}}{{{Hl{c}}D`e}{{Af{g}}}ChCj{}}{{{Hn{c}}D`e}{{Af{g}}}ChCj{}}{{{I`{c}}D`e}{{Af{g}}}ChCj{}}{{{Ib{c}}D`e}{{Af{g}}}ChCj{}}{{{Id{c}}D`e}{{Af{g}}}ChCj{}}{{{If{ce}}D`g}{{Af{i}}}IhChCj{}}{{{In{c}}D`e}{{Af{g}}}ChCj{}}{{{J`{c}}D`e}{{Af{g}}}ChCj{}}{{{Jb{c}}D`e}{{Af{g}}}ChCj{}}{{{Jd{c}}D`e}{{Af{g}}}ChCj{}}{{{Jf{c}}D`e}{{Af{g}}}ChCj{}}{{{Jh{c}}D`e}{{Af{g}}}ChCj{}}{{{Jj{c}}D`e}{{Af{g}}}ChCj{}}{{{Jl{c}}D`e}{{Af{g}}}ChCj{}}{{{Jn{c}}D`e}{{Af{g}}}ChCj{}}{{{K`{c}}D`e}{{Af{g}}}ChCj{}}{{{Kb{c}}D`e}{{Af{g}}}ChCj{}}{{{Kd{c}}D`e}{{Af{g}}}ChCj{}}{{{Kf{c}}D`e}{{Af{g}}}ChCj{}}{{{Kh{c}}D`e}{{Af{g}}}ChCj{}}{{{Kj{c}}D`e}{{Af{g}}}ChCj{}}{{{Kl{gc}}D`i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}D`e}{{Af{g}}}GhCj{}}{{{L`{c}}D`e}{{Af{g}}}GjCj{}}{{{Lb{c}}D`e}{{Af{g}}}HbCj{}}{{{Hf{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Hh{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Hj{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Hl{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Hn{c}}ClD`e}{{Af{g}}}ChCj{}}{{{I`{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Ib{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Id{c}}ClD`e}{{Af{g}}}ChCj{}}{{{If{ce}}ClD`g}{{Af{i}}}IhChCj{}}{{{In{c}}ClD`e}{{Af{g}}}ChCj{}}{{{J`{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jb{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jd{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jf{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jh{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jj{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jl{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Jn{c}}ClD`e}{{Af{g}}}ChCj{}}{{{K`{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kb{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kd{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kf{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kh{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kj{c}}ClD`e}{{Af{g}}}ChCj{}}{{{Kl{gc}}ClD`i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}ClD`e}{{Af{g}}}GhCj{}}{{{L`{c}}ClD`e}{{Af{g}}}GjCj{}}{{{Lb{c}}ClD`e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}e}{{Af{g}}}ChCj{}}{{{Hh{c}}e}{{Af{g}}}ChCj{}}{{{Hj{c}}e}{{Af{g}}}ChCj{}}{{{Hl{c}}e}{{Af{g}}}ChCj{}}{{{Hn{c}}e}{{Af{g}}}ChCj{}}{{{I`{c}}e}{{Af{g}}}ChCj{}}{{{Ib{c}}e}{{Af{g}}}ChCj{}}{{{Id{c}}e}{{Af{g}}}ChCj{}}{{{If{ce}}g}{{Af{i}}}IhChCj{}}{{{In{c}}e}{{Af{g}}}ChCj{}}{{{J`{c}}e}{{Af{g}}}ChCj{}}{{{Jb{c}}e}{{Af{g}}}ChCj{}}{{{Jd{c}}e}{{Af{g}}}ChCj{}}{{{Jf{c}}e}{{Af{g}}}ChCj{}}{{{Jh{c}}e}{{Af{g}}}ChCj{}}{{{Jj{c}}e}{{Af{g}}}ChCj{}}{{{Jl{c}}e}{{Af{g}}}ChCj{}}{{{Jn{c}}e}{{Af{g}}}ChCj{}}{{{K`{c}}e}{{Af{g}}}ChCj{}}{{{Kb{c}}e}{{Af{g}}}ChCj{}}{{{Kd{c}}e}{{Af{g}}}ChCj{}}{{{Kf{c}}e}{{Af{g}}}ChCj{}}{{{Kh{c}}e}{{Af{g}}}ChCj{}}{{{Kj{c}}e}{{Af{g}}}ChCj{}}{{{Kl{gc}}i}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}e}{{Af{g}}}GhCj{}}{{{L`{c}}e}{{Af{g}}}GjCj{}}{{{Lb{c}}e}{{Af{g}}}HbCj{}}{{{Hf{c}}Cle}{{Af{g}}}ChCj{}}{{{Hh{c}}Cle}{{Af{g}}}ChCj{}}{{{Hj{c}}Cle}{{Af{g}}}ChCj{}}{{{Hl{c}}Cle}{{Af{g}}}ChCj{}}{{{Hn{c}}Cle}{{Af{g}}}ChCj{}}{{{I`{c}}Cle}{{Af{g}}}ChCj{}}{{{Ib{c}}Cle}{{Af{g}}}ChCj{}}{{{Id{c}}Cle}{{Af{g}}}ChCj{}}{{{If{ce}}Clg}{{Af{i}}}IhChCj{}}{{{In{c}}Cle}{{Af{g}}}ChCj{}}{{{J`{c}}Cle}{{Af{g}}}ChCj{}}{{{Jb{c}}Cle}{{Af{g}}}ChCj{}}{{{Jd{c}}Cle}{{Af{g}}}ChCj{}}{{{Jf{c}}Cle}{{Af{g}}}ChCj{}}{{{Jh{c}}Cle}{{Af{g}}}ChCj{}}{{{Jj{c}}Cle}{{Af{g}}}ChCj{}}{{{Jl{c}}Cle}{{Af{g}}}ChCj{}}{{{Jn{c}}Cle}{{Af{g}}}ChCj{}}{{{K`{c}}Cle}{{Af{g}}}ChCj{}}{{{Kb{c}}Cle}{{Af{g}}}ChCj{}}{{{Kd{c}}Cle}{{Af{g}}}ChCj{}}{{{Kf{c}}Cle}{{Af{g}}}ChCj{}}{{{Kh{c}}Cle}{{Af{g}}}ChCj{}}{{{Kj{c}}Cle}{{Af{g}}}ChCj{}}{{{Kl{gc}}Cli}{{Af{k}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Cj{}}{{{Kn{c}}Cle}{{Af{g}}}GhCj{}}{{{L`{c}}Cle}{{Af{g}}}GjCj{}}{{{Lb{c}}Cle}{{Af{g}}}HbCj{}}{{{If{ce}}}{{Af{Fde}}}IhCh}{{{Kl{ce}}}{{Af{Fde}}}IhCh}{{IlIl}Db}{{{Hf{c}}Fj}Fl{}}{{{Hh{c}}Fj}Fl{}}{{{Hj{c}}Fj}Fl{}}{{{Hl{c}}Fj}Fl{}}{{{Hn{c}}Fj}Fl{}}{{{I`{c}}Fj}Fl{}}{{{Ib{c}}Fj}Fl{}}{{{Id{c}}Fj}Fl{}}{{{If{ce}}Fj}Fl{IhLd}{}}{{IlFj}Fl}0{{{In{c}}Fj}Fl{}}{{{J`{c}}Fj}Fl{}}{{{Jb{c}}Fj}Fl{}}{{{Jd{c}}Fj}Fl{}}{{{Jf{c}}Fj}Fl{}}{{{Jh{c}}Fj}Fl{}}{{{Jj{c}}Fj}Fl{}}{{{Jl{c}}Fj}Fl{}}{{{Jn{c}}Fj}Fl{}}{{{K`{c}}Fj}Fl{}}{{{Kb{c}}Fj}Fl{}}{{{Kd{c}}Fj}Fl{}}{{{Kf{c}}Fj}Fl{}}{{{Kh{c}}Fj}Fl{}}{{{Kj{c}}Fj}Fl{}}{{{Kl{ce}}Fj}FlLd{}}{{{Kn{c}}Fj}FlLd}{{{L`{c}}Fj}FlLd}{{{Lb{c}}Fj}FlLd}{cc{}}0000000000000000000000000000{ce{}{}}0000000000000000000000000000{{}{{Hf{c}}}{}}{Eh{{Hh{c}}}{}}{Cl{{Hj{c}}}{}}{Cl{{Hl{c}}}{}}{Gl{{Hn{c}}}{}}{{{Lf{Cl}}}{{I`{c}}}{}}{{{Cn{Dd}}}{{Ib{c}}}{}}{{{Cn{Dd}}}{{Id{c}}}{}}{c{{If{ce}}}Ih{}}{Db{{In{c}}}{}}{Ed{{J`{c}}}{}}{Dn{{Jb{c}}}{}}{E`{{Jd{c}}}{}}{Eb{{Jf{c}}}{}}{Dl{{Jh{c}}}{}}{Lh{{Jj{c}}}{}}{Dd{{Jl{c}}}{}}{El{{Jn{c}}}{}}{En{{K`{c}}}{}}{Ej{{Kb{c}}}{}}{D`{{Kd{c}}}{}}{Dh{{Kf{c}}}{}}{Dj{{Kh{c}}}{}}{Df{{Kj{c}}}{}}{c{{Kl{ce}}}Ih{}}{c{{Kn{c}}}{}}{c{{L`{c}}}{}}{c{{Lb{c}}}{}}{{{If{ce}}g}{{Af{Efi}}}IhChFh{}}{{{Kl{gc}}i}{{Af{Efk}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}Fh{}}{{{If{ce}}gi}{{Af{{Ef{Bl}}k}}}IhChFhFh{}}2{{{If{ce}}g}{{Af{i}}}IhChFh{}}{{{If{ce}}}{{Ef{D`}}}IhCh}0{{{Kl{gc}}}{{Ef{D`}}}Ch{{Gd{c}}}{{Ih{}{{Bj{e}}}}}}{ce{}{}}0000000000000000000000000000{cGl{}}{c{{Af{e}}}{}{}}000000000000000000000000000000000000000000000000000000000{cGn{}}0000000000000000000000000000{{{Hh{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{Hj{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{Hl{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{Hn{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{I`{c}}e}{{Af{{Bl{g}}i}}}ChFh{}{}}{{{L`{c}}e}{{Af{{Bl{g}}i}}}GjFh{}{}}```````````````````````````````````99{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ai}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}BhBh{{Bn{}{{Bj{{Bl{AeAg}}}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}Bn}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Cb}}{cAhCb}{{{Aj{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Al{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{An{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{B`{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Bb{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Bd{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Bf{}{{b{c}}{d{e}}}}}{{Af{ce}}}{}Ah}{{{Lj{ce}}}{{Af{ce}}}{}Ah}000000{cc{}}{ce{}{}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}}Db{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{Bhc}AfAd}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Db}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Cn{Dd}}}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Df}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Aj{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Al{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Lj{ce}}g}{{Af{Fde}}}{}Ah{C`Bh}}0{{{Bb{}{{b{c}}{d{e}}}}gi}{{Af{Fde}}}{}Ah{C`Bh}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dh}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dj}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{An{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{B`{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Bd{}{{b{c}}{d{e}}}}Clg}{{Af{Fde}}}{}Ah{C`Bh}}{{{Bf{}{{b{c}}{d{e}}}}Clg}{{Af{Fde}}}{}Ah{C`Bh}}{{{Lj{ce}}Clg}{{Af{Fde}}}{}Ah{C`Bh}}880{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dn}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}E`}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Eb}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ed}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Bb{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}>{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Ef{D`}}}{{Af{oe}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClAe}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClAe}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}{Ef{D`}}}{{Af{ge}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ae}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}{C`Bh}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Cl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClD`}{{Af{Aae}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClD`}{{Af{Ace}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}D`}{{Af{ie}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClD`}{{Af{ke}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhClD`}{{Af{me}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Ej}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}El}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Eh}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}En}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}Dd}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}=:{{{Ad{}{{b{c}}{d{e}}{f{g}}{h{i}}{j{k}}{l{m}}{n{o}}{A`{Aa}}{Ab{Ac}}}}ClEhCl}{{Af{ce}}}{}Ah{{Aj{}{{b{c}}{d{e}}}}}{{Al{}{{b{c}}{d{e}}}}}{{An{}{{b{c}}{d{e}}}}}{{B`{}{{b{c}}{d{e}}}}}{{Bb{}{{b{c}}{d{e}}}}}{{Bd{}{{b{c}}{d{e}}}}}{{Bf{}{{b{c}}{d{e}}}}}}{{{Bb{}{{b{c}}{d{e}}}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Lj{ce}}g}{{Af{Fde}}}{}Ah{C`Bh}}{{{Bd{}{{b{c}}{d{e}}}}Cl}{{Af{Fde}}}{}Ah}{{{Bf{}{{b{c}}{d{e}}}}Cl}{{Af{Fde}}}{}Ah}{c{{Af{e}}}{}{}}0{cGn{}}","D":"CCd","p":[[17,"Ok"],[17,"Error"],[17,"SerializeSeq"],[17,"SerializeTuple"],[17,"SerializeTupleStruct"],[17,"SerializeTupleVariant"],[17,"SerializeMap"],[17,"SerializeStruct"],[17,"SerializeStructVariant"],[10,"Serializer",0,1531],[6,"Result",1642],[10,"Error",1531],[10,"SerializeSeq",1531],[10,"SerializeTuple",1531],[10,"SerializeTupleStruct",1531],[10,"SerializeTupleVariant",1531],[10,"SerializeMap",1531],[10,"SerializeStruct",1531],[10,"SerializeStructVariant",1531],[10,"Serialize",0,1531],[17,"Item"],[1,"tuple"],[10,"IntoIterator",1643],[10,"Sized",1644],[10,"Display",1645],[10,"Deserialize",0,87],[10,"Deserializer",0,87],[10,"Error",87],[10,"Visitor",87],[1,"str"],[1,"slice"],[1,"usize"],[1,"bool"],[1,"u8"],[1,"char"],[1,"f32"],[1,"f64"],[1,"i128"],[1,"i16"],[1,"i32"],[1,"i64"],[1,"i8"],[6,"Option",1646],[1,"u32"],[1,"u128"],[1,"u16"],[1,"u64"],[5,"IgnoredAny",87,1647],[6,"Unexpected",87],[1,"unit"],[17,"Value"],[10,"DeserializeSeed",87],[5,"Formatter",1645],[8,"Result",1645],[10,"Expected",87],[5,"Error",1645],[17,"Deserializer"],[10,"IntoDeserializer",87],[10,"VariantAccess",87],[10,"SeqAccess",87],[10,"MapAccess",87],[5,"String",1648],[5,"TypeId",1649],[17,"Variant"],[10,"EnumAccess",87],[5,"Vec",1650],[5,"UnitDeserializer",265],[5,"U32Deserializer",265],[5,"StrDeserializer",265],[5,"BorrowedStrDeserializer",265],[5,"StringDeserializer",265],[5,"CowStrDeserializer",265],[5,"BytesDeserializer",265],[5,"BorrowedBytesDeserializer",265],[5,"MapDeserializer",265],[10,"Iterator",1651],[10,"Clone",1652],[5,"Error",265],[5,"BoolDeserializer",265],[5,"I8Deserializer",265],[5,"I16Deserializer",265],[5,"I32Deserializer",265],[5,"I64Deserializer",265],[5,"I128Deserializer",265],[5,"IsizeDeserializer",265],[5,"U8Deserializer",265],[5,"U16Deserializer",265],[5,"U64Deserializer",265],[5,"U128Deserializer",265],[5,"UsizeDeserializer",265],[5,"F32Deserializer",265],[5,"F64Deserializer",265],[5,"CharDeserializer",265],[5,"SeqDeserializer",265],[5,"SeqAccessDeserializer",265],[5,"MapAccessDeserializer",265],[5,"EnumAccessDeserializer",265],[10,"Debug",1645],[6,"Cow",1653],[1,"isize"],[5,"Impossible",1531,1654]],"r":[[0,87],[1,1655],[2,87],[6,1531],[7,1655],[15,1531],[105,1647],[1540,1654]],"b":[[182,"impl-Debug-for-Unexpected%3C\'a%3E"],[183,"impl-Display-for-Unexpected%3C\'a%3E"],[410,"impl-Error-for-Error"],[411,"impl-Error-for-Error"],[1293,"impl-Display-for-Error"],[1294,"impl-Debug-for-Error"],[1405,"impl-SeqAccess%3C\'de%3E-for-MapDeserializer%3C\'de,+I,+E%3E"],[1406,"impl-MapAccess%3C\'de%3E-for-MapDeserializer%3C\'de,+I,+E%3E"],[1579,"impl-SerializeTupleStruct-for-Impossible%3COk,+Error%3E"],[1580,"impl-SerializeStructVariant-for-Impossible%3COk,+Error%3E"],[1581,"impl-SerializeTupleVariant-for-Impossible%3COk,+Error%3E"],[1582,"impl-SerializeStruct-for-Impossible%3COk,+Error%3E"],[1583,"impl-SerializeSeq-for-Impossible%3COk,+Error%3E"],[1584,"impl-SerializeTuple-for-Impossible%3COk,+Error%3E"],[1585,"impl-SerializeMap-for-Impossible%3COk,+Error%3E"],[1595,"impl-SerializeTuple-for-Impossible%3COk,+Error%3E"],[1596,"impl-SerializeSeq-for-Impossible%3COk,+Error%3E"],[1604,"impl-SerializeStruct-for-Impossible%3COk,+Error%3E"],[1605,"impl-SerializeTupleVariant-for-Impossible%3COk,+Error%3E"],[1606,"impl-SerializeTupleStruct-for-Impossible%3COk,+Error%3E"],[1607,"impl-SerializeStructVariant-for-Impossible%3COk,+Error%3E"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAANAEJQB1AAAAggAHAIsAAACOAAAArwABALIAAAC0AAQA0AAGANgAAQDhAAAA5gAAAOkAAADsAAAA7gAAAPIAAAD1AAAA9wAAAPkAAAD7AAAA/QAAAP8AAAACAQAABgEAAAkBAAAnAdoDBAUeAF0FAgBhBQEAZgUOAHkFggAeBgIALAYGADwGAQBFBgMATwYAAGUGAABoBgIA"}],\ ["serde_derive",{"t":"YY","n":["Deserialize","Serialize"],"q":[[0,"serde_derive"]],"i":[0,0],"f":"``","D":"b","p":[],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAEAAAAAAAEAEAAAAAEAAgA="}],\ ["serde_derive_internals",{"t":"FGPPCCNNNNNNNNNNNNNNNHNNNNNNNNHFGPFPPPGPPFNOOONNNNNNNNNNNNOONNNNNNONOONNNNNOOOOONNNNNNNNNNNONNNNNPPFGPPFPGPPPFPPPPPPFGPPPGPFPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOO","n":["Ctxt","Derive","Deserialize","Serialize","ast","attr","borrow","borrow","borrow_mut","borrow_mut","check","clone","clone_into","default","drop","error_spanned_by","from","from","into","into","new","replace_receiver","syn_error","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","ungroup","Container","Data","Enum","Field","Newtype","Struct","Struct","Style","Tuple","Unit","Variant","all_fields","attrs","attrs","attrs","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","data","fields","from","from","from","from","from","from_ast","generics","has_getter","ident","ident","into","into","into","into","into","member","original","original","original","style","to_owned","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","ty","type_id","type_id","type_id","type_id","type_id","Adjacent","CamelCase","Container","Default","Default","External","Field","Field","Identifier","Internal","KebabCase","LowerCase","Name","No","None","None","None","PascalCase","Path","RenameAllRules","RenameRule","ScreamingKebabCase","ScreamingSnakeCase","SnakeCase","TagType","UpperCase","Variant","Variant","aliases","aliases","apply_to_field","apply_to_variant","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrowed_lifetimes","clone","clone","clone","clone_into","clone_into","clone_into","custom_serde_path","de_bound","de_bound","de_bound","default","default","deny_unknown_fields","deserialize","deserialize_name","deserialize_with","deserialize_with","eq","expecting","flatten","from","from","from","from","from","from","from","from","from","from_ast","from_ast","from_ast","from_str","getter","has_flatten","identifier","into","into","into","into","into","into","into","into","into","is_none","is_packed","mark_has_flatten","mark_transparent","name","name","name","non_exhaustive","or","or","other","remote","rename_all_fields_rules","rename_all_rules","rename_all_rules","rename_by_rules","rename_by_rules","ser_bound","ser_bound","ser_bound","serde_path","serialize","serialize_name","serialize_with","serialize_with","skip_deserializing","skip_deserializing","skip_serializing","skip_serializing","skip_serializing_if","tag","to_owned","to_owned","to_owned","transparent","transparent","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_from","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_into","type_try_from","untagged","content","tag","tag"],"q":[[0,"serde_derive_internals"],[31,"serde_derive_internals::ast"],[97,"serde_derive_internals::attr"],[260,"serde_derive_internals::attr::TagType"],[263,"serde_derive_internals::internals::ctxt"],[264,"syn::error"],[265,"serde_derive_internals::internals"],[266,"quote::to_tokens"],[267,"core::fmt"],[268,"syn::derive"],[269,"core::result"],[270,"core::any"],[271,"syn::ty"],[272,"serde_derive_internals::internals::ast"],[273,"core::iter::traits::iterator"],[274,"alloc::boxed"],[275,"core::option"],[276,"serde_derive_internals::internals::attr"],[277,"alloc::string"],[278,"alloc::collections::btree::set"],[279,"serde_derive_internals::internals::case"],[280,"syn::lifetime"],[281,"syn::path"],[282,"syn::generics"],[283,"syn::expr"],[284,"syn::data"],[285,"alloc::borrow"],[286,"serde_derive_internals::internals::receiver"]],"i":[0,0,4,4,0,0,1,4,1,4,1,4,4,1,1,1,1,4,1,4,1,0,1,4,1,4,1,4,1,4,0,0,0,12,0,15,12,15,0,15,15,0,12,16,40,41,16,12,40,41,15,16,12,40,41,15,15,15,16,40,16,12,40,41,15,16,16,12,16,40,16,12,40,41,15,41,16,40,41,40,15,16,12,40,41,15,16,12,40,41,15,41,16,12,40,41,15,39,23,0,0,32,39,0,27,0,39,23,23,0,27,39,32,23,23,32,0,0,23,23,23,0,23,0,27,19,22,23,23,33,28,39,19,22,32,26,27,23,33,28,39,19,22,32,26,27,23,22,26,27,23,26,27,23,28,28,19,22,28,22,28,26,33,19,22,23,28,22,33,28,39,19,22,32,26,27,23,28,19,22,23,22,28,28,33,28,39,19,22,32,26,27,23,32,28,28,22,28,19,22,28,26,23,19,28,28,28,19,19,22,28,19,22,28,26,33,19,22,19,22,19,22,22,28,26,27,23,28,22,33,28,39,19,22,32,26,27,23,33,28,39,19,22,32,26,27,23,28,33,28,39,19,22,32,26,27,23,28,28,19,42,43,42],"f":"``````{ce{}{}}000{b{{f{d}}}}{hh}{{ce}d{}{}}{{}b}{bd}{{bce}djl}{cc{}}0773{nd}{{bA`}d}9{c{{Ab{e}}}{}{}}000{cAd{}}0{AfAf}```````````{Ah{{Al{Aj}}}}```=========={AnAn};``77777{{bnh}{{Bb{B`}}}}`{AhBd}``{ce{}{}}0000`````07777777777`66666````````````````````````````{Bf{{Bj{Bh}}}}{Bl{{Bj{Bh}}}}{{BnC`}Bh}0333333333333333333{Bl{{Bj{Cb}}}}{CdCd}{CfCf}{BnBn}{{ce}d{}{}}00{Ch{{Bb{Cj}}}}{Ch{{Bb{{Cn{Cl}}}}}}{Bf{{Bb{{Cn{Cl}}}}}}{Bl{{Bb{{Cn{Cl}}}}}}{ChD`}{BlD`}{ChBd}`{DbC`}{Bf{{Bb{Dd}}}}{Bl{{Bb{Dd}}}}{{BnBn}Bd}{Ch{{Bb{C`}}}}{BlBd}{cc{}}00000000{{bn}Ch}{{bDf}Bf}{{bDhDj{Bb{Bf}}D`}Bl}{C`{{Ab{Bn`}}}}8;{ChCf}{ce{}{}}00000000{D`Bd}>{Chd}{Bld}{ChDb}{BfDb}{BlDb}{ChBd}{{CdCd}Cd}{{BnBn}Bn}{BfBd}{Ch{{Bb{Cj}}}}{ChCd}0{BfCd}{{BfCd}d}{{BlCd}d}{Ch{{Bb{{Cn{Cl}}}}}}{Bf{{Bb{{Cn{Cl}}}}}}{Bl{{Bb{{Cn{Cl}}}}}}{Ch{{Dl{Cj}}}}`{DbC`}{Bf{{Bb{Dd}}}}{Bl{{Bb{Dd}}}}<{BlBd}=01{ChDn}{ce{}{}}00{ChBd}3{c{{Ab{e}}}{}{}}00000000000000000{Ch{{Bb{Af}}}}{cAd{}}0000000011{BfBd}```","D":"Jn","p":[[5,"Ctxt",0,263],[1,"unit"],[8,"Result",264],[6,"Derive",0,265],[10,"ToTokens",266],[10,"Display",267],[5,"DeriveInput",268],[5,"Error",264],[6,"Result",269],[5,"TypeId",270],[6,"Type",271],[6,"Data",31,272],[10,"Iterator",273],[5,"Box",274],[6,"Style",31,272],[5,"Container",31,272],[6,"Option",275],[1,"bool"],[5,"Variant",97,276],[5,"String",277],[5,"BTreeSet",278],[5,"Field",97,276],[6,"RenameRule",97,279],[1,"str"],[5,"Lifetime",280],[5,"RenameAllRules",97,276],[6,"Identifier",97,276],[5,"Container",97,276],[5,"Path",281],[6,"WherePredicate",282],[1,"slice"],[6,"Default",97,276],[5,"Name",97,276],[5,"ExprPath",283],[5,"Variant",284],[1,"usize"],[5,"Field",284],[6,"Cow",285],[6,"TagType",97,276],[5,"Variant",31],[5,"Field",31],[15,"Adjacent",260],[15,"Internal",260]],"r":[[0,263],[1,265],[4,265],[5,265],[21,286],[30,265],[31,272],[32,272],[34,272],[38,272],[41,272],[99,276],[100,276],[103,276],[105,276],[109,276],[116,276],[117,279],[121,276],[123,276]],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAALAAGwAAAAAAAgACAAYABAAMAAMAFgAAABgABwAiAAAAJQAAACcAAAArAAAALQANADwAAABEAAAARgAAAEwAAABOABMAbgAAAHUAAAB+AAEAggAgAKQAAgCoAAAAswAAALUAAwDCAAcAzAALANkALgA="}],\ ["serde_json",{"t":"PPFPFFPFPPPIFFPGNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHHNHNNNNNNNNNNNNNNNNNNQCNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNHHHHHHNNNNNNNNNNNNNNNNNNCFFKFFFNNNNNNNNNNNHNHNHNNNNNNNNNNNNNNNNNNNGPPPFPPIPNNNNNNNNNNNNNNNNNNNNGFFFFFPFPFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPPPGFPKPFPPFPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPPKEPFPPFPGNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNN","n":["Array","Bool","Deserializer","Err","Error","Map","Null","Number","Number","Object","Ok","Result","Serializer","StreamDeserializer","String","Value","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_from","clone_into","clone_into","collect_str","custom","custom","de","default","default","deserialize","deserialize","deserialize_any","deserialize_any","deserialize_any","deserialize_bool","deserialize_bool","deserialize_bool","deserialize_byte_buf","deserialize_byte_buf","deserialize_byte_buf","deserialize_bytes","deserialize_bytes","deserialize_bytes","deserialize_char","deserialize_char","deserialize_char","deserialize_enum","deserialize_enum","deserialize_enum","deserialize_f32","deserialize_f32","deserialize_f32","deserialize_f64","deserialize_f64","deserialize_f64","deserialize_i128","deserialize_i128","deserialize_i128","deserialize_i16","deserialize_i16","deserialize_i16","deserialize_i32","deserialize_i32","deserialize_i32","deserialize_i64","deserialize_i64","deserialize_i64","deserialize_i8","deserialize_i8","deserialize_i8","deserialize_identifier","deserialize_identifier","deserialize_identifier","deserialize_ignored_any","deserialize_ignored_any","deserialize_ignored_any","deserialize_map","deserialize_map","deserialize_map","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_option","deserialize_option","deserialize_option","deserialize_seq","deserialize_seq","deserialize_seq","deserialize_str","deserialize_str","deserialize_str","deserialize_string","deserialize_string","deserialize_string","deserialize_struct","deserialize_struct","deserialize_struct","deserialize_tuple","deserialize_tuple","deserialize_tuple","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_u128","deserialize_u128","deserialize_u128","deserialize_u16","deserialize_u16","deserialize_u16","deserialize_u32","deserialize_u32","deserialize_u32","deserialize_u64","deserialize_u64","deserialize_u64","deserialize_u8","deserialize_u8","deserialize_u8","deserialize_unit","deserialize_unit","deserialize_unit","deserialize_unit_struct","deserialize_unit_struct","deserialize_unit_struct","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","error","extend","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_iter","from_iter","from_iter","from_reader","from_slice","from_str","from_str","from_value","index","index","index_mut","index_mut","into","into","into","into","into","into","into_deserializer","into_deserializer","into_iter","into_iter","into_iter","into_iter","invalid_type","invalid_value","json","map","next","ser","serialize","serialize","serialize_bool","serialize_bytes","serialize_char","serialize_f32","serialize_f64","serialize_i128","serialize_i16","serialize_i32","serialize_i64","serialize_i8","serialize_map","serialize_newtype_struct","serialize_newtype_variant","serialize_none","serialize_seq","serialize_some","serialize_str","serialize_struct","serialize_struct_variant","serialize_tuple","serialize_tuple_struct","serialize_tuple_variant","serialize_u128","serialize_u16","serialize_u32","serialize_u64","serialize_u8","serialize_unit","serialize_unit_struct","serialize_unit_variant","source","to_owned","to_owned","to_string","to_string","to_string","to_string_pretty","to_value","to_vec","to_vec_pretty","to_writer","to_writer_pretty","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","value","Deserializer","IoRead","Read","SliceRead","StrRead","StreamDeserializer","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","byte_offset","end","from","from","from","from_reader","from_reader","from_slice","from_slice","from_str","from_str","into","into","into","into_iter","new","new","new","new","new","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","Category","Data","Eof","Err","Error","Io","Ok","Result","Syntax","borrow","borrow_mut","classify","clone","clone_into","column","eq","fmt","from","into","io_error_kind","is_data","is_eof","is_io","is_syntax","line","to_owned","try_from","try_into","type_id","Entry","IntoIter","Iter","IterMut","Keys","Map","Occupied","OccupiedEntry","Vacant","VacantEntry","Values","ValuesMut","and_modify","append","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clear","contains_key","entry","from","from","from","from","from","from","from","from","from","get","get","get_key_value","get_mut","get_mut","insert","insert","insert","into","into","into","into","into","into","into","into","into","into_iter","into_iter","into_iter","into_iter","into_iter","into_iter","into_mut","is_empty","iter","iter_mut","key","key","key","keys","len","len","len","len","len","len","len","new","next","next","next","next","next","next","next_back","next_back","next_back","next_back","next_back","next_back","or_insert","or_insert_with","remove","remove","remove_entry","retain","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","values","values_mut","with_capacity","AsciiControl","Backspace","CarriageReturn","CharEscape","CompactFormatter","FormFeed","Formatter","LineFeed","PrettyFormatter","Quote","ReverseSolidus","Serializer","Solidus","Tab","begin_array","begin_array","begin_array_value","begin_array_value","begin_object","begin_object","begin_object_key","begin_object_key","begin_object_value","begin_object_value","begin_string","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","default","end_array","end_array","end_array_value","end_array_value","end_object","end_object","end_object_key","end_object_value","end_object_value","end_string","fmt","fmt","from","from","from","into","into","into","into_inner","new","new","pretty","to_owned","to_owned","to_string","to_string_pretty","to_vec","to_vec_pretty","to_writer","to_writer_pretty","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","with_formatter","with_indent","write_bool","write_byte_array","write_char_escape","write_f32","write_f64","write_i128","write_i16","write_i32","write_i64","write_i8","write_null","write_number_str","write_raw_fragment","write_string_fragment","write_u128","write_u16","write_u32","write_u64","write_u8","Array","Bool","Index","Map","Null","Number","Number","Object","Serializer","String","Value","as_array","as_array_mut","as_bool","as_f64","as_f64","as_i64","as_i64","as_null","as_number","as_object","as_object_mut","as_str","as_u64","as_u64","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","collect_str","deserialize","deserialize_any","deserialize_any","deserialize_bool","deserialize_bool","deserialize_byte_buf","deserialize_byte_buf","deserialize_bytes","deserialize_bytes","deserialize_char","deserialize_char","deserialize_enum","deserialize_enum","deserialize_f32","deserialize_f32","deserialize_f64","deserialize_f64","deserialize_i128","deserialize_i128","deserialize_i16","deserialize_i16","deserialize_i32","deserialize_i32","deserialize_i64","deserialize_i64","deserialize_i8","deserialize_i8","deserialize_identifier","deserialize_identifier","deserialize_ignored_any","deserialize_ignored_any","deserialize_map","deserialize_map","deserialize_newtype_struct","deserialize_newtype_struct","deserialize_option","deserialize_option","deserialize_seq","deserialize_seq","deserialize_str","deserialize_str","deserialize_string","deserialize_string","deserialize_struct","deserialize_struct","deserialize_tuple","deserialize_tuple","deserialize_tuple_struct","deserialize_tuple_struct","deserialize_u128","deserialize_u128","deserialize_u16","deserialize_u16","deserialize_u32","deserialize_u32","deserialize_u64","deserialize_u64","deserialize_u8","deserialize_u8","deserialize_unit","deserialize_unit","deserialize_unit_struct","deserialize_unit_struct","eq","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from_f64","from_str","from_value","get","get_mut","hash","into","into","is_array","is_boolean","is_f64","is_f64","is_i64","is_i64","is_null","is_number","is_object","is_string","is_u64","is_u64","pointer","pointer_mut","serialize","serialize_bool","serialize_bytes","serialize_char","serialize_f32","serialize_f64","serialize_i128","serialize_i16","serialize_i32","serialize_i64","serialize_i8","serialize_map","serialize_newtype_struct","serialize_newtype_variant","serialize_none","serialize_seq","serialize_some","serialize_str","serialize_struct","serialize_struct_variant","serialize_tuple","serialize_tuple_struct","serialize_tuple_variant","serialize_u128","serialize_u16","serialize_u32","serialize_u64","serialize_u8","serialize_unit","serialize_unit_struct","serialize_unit_variant","take","to_owned","to_string","to_value","try_from","try_from","try_into","try_into","type_id","type_id"],"q":[[0,"serde_json"],[306,"serde_json::de"],[347,"serde_json::error"],[376,"serde_json::map"],[513,"serde_json::ser"],[609,"serde_json::value"],[782,"alloc::string"],[783,"std::io"],[784,"core::marker"],[785,"core::fmt"],[786,"core::result"],[787,"serde::de"],[788,"serde_json::read"],[789,"core::iter::traits::collect"],[790,"alloc::borrow"],[791,"core::clone"],[792,"core::convert"],[793,"core::option"],[794,"alloc::vec"],[795,"serde_json::number"],[796,"core::cmp"],[797,"core::hash"],[798,"serde_json::value::index"],[799,"serde::ser"],[800,"core::error"],[801,"core::any"],[802,"std::io::error"],[803,"core::ops::function"],[804,"serde_json::value::ser"]],"i":[2,2,0,6,0,0,2,0,2,2,6,0,0,0,2,0,14,53,11,3,5,2,14,53,11,3,5,2,3,2,3,3,2,5,11,11,0,3,2,3,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,14,2,2,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,3,11,11,3,2,2,14,53,11,3,5,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,2,2,0,0,0,2,0,3,2,3,2,14,53,11,3,5,2,2,2,53,3,3,3,11,11,0,0,53,0,3,2,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,11,3,2,0,11,2,0,0,0,0,0,0,14,53,11,3,5,2,14,53,11,3,5,2,14,53,11,3,5,2,0,0,0,0,0,0,0,61,62,63,61,62,63,53,14,61,62,63,0,14,0,14,0,14,61,62,63,14,14,53,61,62,63,61,62,63,61,62,63,61,62,63,0,64,64,6,0,64,6,0,64,64,64,11,64,64,11,64,64,64,64,11,11,11,11,11,11,64,64,64,64,0,0,0,0,0,0,66,0,66,0,0,0,66,3,66,69,68,70,71,73,72,74,75,66,69,68,70,71,73,72,74,75,3,3,3,66,69,68,70,71,73,72,74,75,3,68,3,3,68,3,69,68,66,69,68,70,71,73,72,74,75,70,71,73,72,74,75,68,3,3,3,66,69,68,3,3,70,71,73,72,74,75,3,70,71,73,72,74,75,70,71,73,72,74,75,66,66,3,68,3,3,70,71,73,72,74,75,66,69,68,70,71,73,72,74,75,66,69,68,70,71,73,72,74,75,66,69,68,70,71,73,72,74,75,3,3,3,81,81,81,0,0,81,0,81,0,81,81,0,81,81,8,79,8,79,8,79,8,79,8,79,8,81,80,79,81,80,79,80,79,80,79,79,8,79,8,79,8,79,8,8,79,8,80,79,81,80,79,81,80,79,5,5,79,5,80,79,0,0,0,0,0,0,81,80,79,81,80,79,81,80,79,5,79,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,2,2,0,0,2,0,2,2,0,2,0,2,2,2,2,43,2,43,2,2,2,2,2,2,43,82,43,82,43,43,43,82,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,82,43,43,43,43,43,43,43,43,43,43,43,43,43,0,2,2,43,82,43,2,2,2,43,2,43,2,2,2,2,2,43,2,2,43,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,82,2,43,43,0,82,43,82,43,82,43],"f":"````````````````{ce{}{}}00000000000{{{f{bd}}}{{f{bd}}}}{dd}{{{f{bd}}{f{bd}}}h}{{ce}h{}{}}0{{{j{ce}}g}{{l{h}}}nA`{AbAd}}{cAfAd}0`{{}{{f{bd}}}}{{}d}{c{{Ah{{f{bd}}}}}Aj}{c{{Ah{d}}}Aj}{{{Al{c}}e}lAnB`}{{dc}{{Ah{Af}}}B`}0100100100100{{{Al{c}}Bb{Bd{Bb}}e}lAnB`}{{dBb{Bd{Bb}}c}{{Ah{Af}}}B`}0322322322322322322322322322322{{{Al{c}}Bbe}lAnB`}{{dBbc}{{Ah{Af}}}B`}0544544544544322{{{Al{c}}Bfe}lAnB`}{{dBfc}{{Ah{Af}}}B`}0{{{Al{c}}BbBfe}lAnB`}{{dBbBfc}{{Ah{Af}}}B`}0988988988988988988544{{{f{bd}}{f{bd}}}Bh}{{dBj}Bh}{{dBl}Bh}{{dBn}Bh}{{dC`}Bh}1{{dCb}Bh}{{dBf}Bh}{{dCd}Bh}10{{dBh}Bh}{{db}Bh}2{{dCf}Bh}{{dCh}Bh}{{dd}Bh}81986{{dCj}Bh}{{dCl}Bh}1={{dCn}Bh}>=57{{dBb}Bh}122351;>80;6`{{{f{bd}}c}h{{Dd{}{{D`{{Db{bd}}}}}}}}{{AfDf}Dh}0{{{f{bd}}Df}{{Ah{hDj}}}}{{dDf}Dh}0{cc{}}0000{Cfd}{Chd}{Cld}{Bfd}{Bnd}5{Cjd}{hd}{Bjd}{Bhd}{Cnd}{bd}{{{Dl{Bb}}}d}{Bld}{C`d}{Bbd}{{{f{bd}}}d}{{{Bd{c}}}d{Dn{E`{d}}}}{{{Eb{c}}}d{{E`{d}}}}{Cbd}{{{Ed{c}}}d{{E`{d}}}}{Efd}{Cdd}{c{{f{bd}}}{{Dd{}{{D`{{Db{bd}}}}}}}}{gd{{E`{b}}}{{E`{d}}}{{Dd{}{{D`{{Db{ce}}}}}}}}{ed{{E`{d}}}{{Dd{}{{D`{c}}}}}}{c{{l{e}}}EhEj}{{{Bd{Cf}}}{{l{c}}}El}{Bb{{l{c}}}El}{Bb{{Ah{dAf}}}}{d{{Ah{cAf}}}Ej}{{{f{bd}}c}d{AbEnF`Fb}}{{dc}dFd}10{ce{}{}}00000{dc{}}01{{{f{bd}}}c{}}00{{FfFh}Af}0``{{{Fj{ce}}}{{Eb{{l{e}}}}}AnEl}`{{{f{bd}}c}AhFl}{{dc}AhFl}{{{j{ce}}Bh}{{l{h}}}nA`}{{{j{ce}}{Bd{Cf}}}{{l{h}}}nA`}{{{j{ce}}Fn}{{l{h}}}nA`}{{{j{ce}}Bj}{{l{h}}}nA`}{{{j{ce}}Ch}{{l{h}}}nA`}{{{j{ce}}G`}{{l{h}}}nA`}{{{j{ce}}Cb}{{l{h}}}nA`}{{{j{ce}}C`}{{l{h}}}nA`}{{{j{ce}}Bn}{{l{h}}}nA`}{{{j{ce}}Cl}{{l{h}}}nA`}{{{j{ce}}{Eb{Bf}}}{{l{g}}}nA`{}}{{{j{ce}}Bbg}{{l{h}}}nA`{AbGb}}{{{j{ce}}BbCjBbg}{{l{h}}}nA`{AbGb}}{{{j{ce}}}{{l{h}}}nA`}3{{{j{ce}}g}{{l{h}}}nA`{AbGb}}{{{j{ce}}Bb}{{l{h}}}nA`}{{{j{ce}}BbBf}{{l{g}}}nA`{}}{{{j{ce}}BbCjBbBf}{{l{g}}}nA`{}}{{{j{ce}}Bf}{{l{g}}}nA`{}}21{{{j{ce}}Gd}{{l{h}}}nA`}{{{j{ce}}Cd}{{l{h}}}nA`}{{{j{ce}}Cj}{{l{h}}}nA`}{{{j{ce}}Bl}{{l{h}}}nA`}{{{j{ce}}Cf}{{l{h}}}nA`}:8{{{j{ce}}BbCjBb}{{l{h}}}nA`}{Af{{Eb{Gf}}}}{ce{}{}}0{c{{l{b}}}{AbGb}}{cb{}}01{c{{Ah{dAf}}}Gb}{c{{l{{Ed{Cf}}}}}{AbGb}}0{{ce}{{l{h}}}n{AbGb}}0{c{{Ah{e}}}{}{}}00000000000{cGh{}}00000```````777777{{{Fj{ce}}}BfAnEl}{{{Al{c}}}{{l{h}}}An}{cc{}}00{c{{l{e}}}EhEj}{c{{Al{{Gj{c}}}}}Eh}{{{Bd{Cf}}}{{l{c}}}El}{{{Bd{Cf}}}{{Al{Gl}}}}{Bb{{l{c}}}El}{Bb{{Al{Gn}}}}{ce{}{}}00{{{Al{c}}}{{Fj{ce}}}AnEl}{c{{Al{c}}}An}{c{{Fj{ce}}}AnEl}{c{{Gj{c}}}Eh}{{{Bd{Cf}}}Gl}{BbGn}{c{{Ah{e}}}{}{}}00000{cGh{}}00`````````88{AfH`}{H`H`}{{ce}h{}{}}{AfBf}{{H`H`}Bh}{{H`Df}Dh}{cc{}}?{Af{{Eb{Hb}}}}{AfBh}0005{ce{}{}};;:````````````{{Hdc}Hd{{Hf{d}}}}{{{f{bd}}{f{bd}}}h}222222222222222222{{{f{bd}}}h}{{{f{bd}}c}Bh{AbEnF`Fb}}{{{f{bd}}c}Hd{{E`{b}}}}888888888{{{f{bd}}c}{{Eb{d}}}{AbEnF`Fb}}{Hhd}{{{f{bd}}c}{{Eb{{Db{bd}}}}}{AbEnF`Fb}}21{{{f{bd}}bd}{{Eb{d}}}}{{Hjd}d}{{Hhd}d};;;;;;;;;;;;;;;4{{{f{bd}}}Bh}{{{f{bd}}}Hl}{{{f{bd}}}Hn}{Hdb}{Hjb}{Hhb}{{{f{bd}}}I`}{{{f{bd}}}Bf}{HlBf}{HnBf}{IbBf}{I`Bf}{IdBf}{IfBf}{{}{{f{bd}}}}{Hl{{Eb{c}}}{}}{Hn{{Eb{c}}}{}}{Ib{{Eb{c}}}{}}{I`{{Eb{c}}}{}}{Id{{Eb{c}}}{}}{If{{Eb{c}}}{}}543210{{Hdd}d}{{Hdc}d{{Hf{}{{Ih{d}}}}}}{{{f{bd}}c}{{Eb{d}}}{AbEnF`Fb}}{Hhd}{{{f{bd}}c}{{Eb{{Db{bd}}}}}{AbEnF`Fb}}{{{f{bd}}c}h{{Ij{bd}{{Ih{Bh}}}}}}{Hl{{Db{Bf{Eb{Bf}}}}}}{Hn{{Db{Bf{Eb{Bf}}}}}}{Ib{{Db{Bf{Eb{Bf}}}}}}{I`{{Db{Bf{Eb{Bf}}}}}}{Id{{Db{Bf{Eb{Bf}}}}}}{If{{Db{Bf{Eb{Bf}}}}}}{c{{Ah{e}}}{}{}}00000000000000000{cGh{}}00000000{{{f{bd}}}Id}{{{f{bd}}}If}{Bf{{f{bd}}}}``````````````{{A`c}{{Il{h}}}{Abn}}{{Inc}{{Il{h}}}{Abn}}{{A`cBh}{{Il{h}}}{Abn}}{{IncBh}{{Il{h}}}{Abn}}3210323{ce{}{}}00000{J`J`}{InIn}{{ce}h{}{}}0{{}In}8787878878{{J`Df}Dh}{{InDf}Dh}{cc{}}00777{{{j{ce}}}cnA`}{c{{j{c}}}n}5{c{{j{cIn}}}n}::{c{{l{b}}}{AbGb}}0{c{{l{{Ed{Cf}}}}}{AbGb}}0{{ce}{{l{h}}}n{AbGb}}0{c{{Ah{e}}}{}{}}00000{cGh{}}00{{ce}{{j{ce}}}nA`}{{{Bd{Cf}}}In}{{A`cBh}{{Il{h}}}{Abn}}{{A`c{Bd{Cf}}}{{Il{h}}}{Abn}}{{A`cJb}{{Il{h}}}{Abn}}{{A`cBj}{{Il{h}}}{Abn}}{{A`cCh}{{Il{h}}}{Abn}}{{A`cG`}{{Il{h}}}{Abn}}{{A`cCb}{{Il{h}}}{Abn}}{{A`cC`}{{Il{h}}}{Abn}}{{A`cBn}{{Il{h}}}{Abn}}{{A`cCl}{{Il{h}}}{Abn}}{{A`c}{{Il{h}}}{Abn}}{{A`cBb}{{Il{h}}}{Abn}}00{{A`cGd}{{Il{h}}}{Abn}}{{A`cCd}{{Il{h}}}{Abn}}{{A`cCj}{{Il{h}}}{Abn}}{{A`cBl}{{Il{h}}}{Abn}}{{A`cCf}{{Il{h}}}{Abn}}```````````{d{{Eb{{Ed{d}}}}}}0{d{{Eb{Bh}}}}{d{{Eb{Ch}}}}{Ef{{Eb{Ch}}}}{d{{Eb{Bn}}}}{Ef{{Eb{Bn}}}}{d{{Eb{h}}}}{d{{Eb{Ef}}}}{d{{Eb{{f{bd}}}}}}0{d{{Eb{Bb}}}}{d{{Eb{Bl}}}}{Ef{{Eb{Bl}}}}{ce{}{}}000{EfEf}{{ce}h{}{}}{{Jdc}{{l{d}}}{AbAd}}{c{{Ah{Ef}}}Aj}{{Efc}{{Ah{Af}}}B`}0{{Efc}{{Ah{e}}}B`{}}0000000{{EfBb{Bd{Bb}}c}{{Ah{e}}}B`{}}022222222222222111111{{EfBbc}{{Ah{e}}}B`{}}02222222211{{EfBfc}{{Ah{e}}}B`{}}0{{EfBbBfc}{{Ah{e}}}B`{}}055555555554422{{EfEf}Bh}{{EfDf}Dh}0{cc{}}0{ClEf}{BnEf}{CjEf}{CdEf}{CnEf}{BlEf}{C`Ef}{CfEf}{BfEf}{CbEf}{Ch{{Eb{Ef}}}}{Bb{{Ah{Efc}}}{}}{d{{Ah{cAf}}}Ej}{{dc}{{Eb{d}}}Fd}0{{Efc}hJf}{ce{}{}}0{dBh}00{EfBh}10111110{{dBb}{{Eb{d}}}}0{{Efc}AhFl}{{JdBh}{{l{d}}}}{{Jd{Bd{Cf}}}{{l{d}}}}{{JdFn}{{l{d}}}}{{JdBj}{{l{d}}}}{{JdCh}{{l{d}}}}{{JdG`}{{l{d}}}}{{JdCb}{{l{d}}}}{{JdC`}{{l{d}}}}{{JdBn}{{l{d}}}}{{JdCl}{{l{d}}}}{{Jd{Eb{Bf}}}{{l{c}}}{}}{{JdBbc}{{l{d}}}{AbGb}}{{JdBbCjBbc}{{l{d}}}{AbGb}}{Jd{{l{d}}}}3{{Jdc}{{l{d}}}{AbGb}}{{JdBb}{{l{d}}}}{{JdBbBf}{{l{c}}}{}}{{JdBbCjBbBf}{{l{c}}}{}}{{JdBf}{{l{c}}}{}}21{{JdGd}{{l{d}}}}{{JdCd}{{l{d}}}}{{JdCj}{{l{d}}}}{{JdBl}{{l{d}}}}{{JdCf}{{l{d}}}}:8{{JdBbCjBb}{{l{d}}}}{dd}{ce{}{}}{cb{}}{c{{Ah{dAf}}}Gb}{c{{Ah{e}}}{}{}}000{cGh{}}0","D":"BCj","p":[[5,"String",782],[6,"Value",0,609],[5,"Map",0,376],[1,"unit"],[5,"Serializer",0,513],[8,"Result",0,347],[10,"Write",783],[10,"Formatter",513],[10,"Sized",784],[10,"Display",785],[5,"Error",0,347],[6,"Result",786],[10,"Deserializer",787],[5,"Deserializer",0,306],[10,"Read",306,788],[10,"Visitor",787],[1,"str"],[1,"slice"],[1,"usize"],[1,"bool"],[1,"f32"],[1,"u64"],[1,"i64"],[1,"i32"],[1,"i16"],[1,"u16"],[1,"u8"],[1,"f64"],[1,"u32"],[1,"i8"],[1,"isize"],[17,"Item"],[1,"tuple"],[10,"IntoIterator",789],[5,"Formatter",785],[8,"Result",785],[5,"Error",785],[6,"Cow",790],[10,"Clone",791],[10,"Into",792],[6,"Option",793],[5,"Vec",794],[5,"Number",609,795],[10,"Read",783],[10,"DeserializeOwned",787],[10,"Deserialize",787],[10,"Ord",796],[10,"Eq",796],[10,"Hash",797],[10,"Index",609,798],[6,"Unexpected",787],[10,"Expected",787],[5,"StreamDeserializer",0,306],[10,"Serializer",799],[1,"char"],[1,"i128"],[10,"Serialize",799],[1,"u128"],[10,"Error",800],[5,"TypeId",801],[5,"IoRead",306,788],[5,"SliceRead",306,788],[5,"StrRead",306,788],[6,"Category",347],[6,"ErrorKind",802],[6,"Entry",376],[10,"FnOnce",803],[5,"OccupiedEntry",376],[5,"VacantEntry",376],[5,"Iter",376],[5,"IterMut",376],[5,"Keys",376],[5,"IntoIter",376],[5,"Values",376],[5,"ValuesMut",376],[17,"Output"],[10,"FnMut",803],[8,"Result",802],[5,"PrettyFormatter",513],[5,"CompactFormatter",513],[6,"CharEscape",513],[5,"Serializer",609,804],[10,"Hasher",797]],"r":[[2,306],[4,347],[5,376],[7,795],[11,347],[12,513],[13,306],[15,609],[216,306],[217,306],[218,306],[220,609],[278,513],[281,513],[282,609],[283,513],[284,513],[285,513],[286,513],[307,788],[308,788],[309,788],[310,788],[611,798],[612,376],[614,795],[617,804]],"b":[[34,"impl-Error-for-Error"],[35,"impl-Error-for-Error"],[42,"impl-Deserializer%3C\'de%3E-for-%26Value"],[43,"impl-Deserializer%3C\'de%3E-for-Value"],[45,"impl-Deserializer%3C\'de%3E-for-%26Value"],[46,"impl-Deserializer%3C\'de%3E-for-Value"],[48,"impl-Deserializer%3C\'de%3E-for-%26Value"],[49,"impl-Deserializer%3C\'de%3E-for-Value"],[51,"impl-Deserializer%3C\'de%3E-for-%26Value"],[52,"impl-Deserializer%3C\'de%3E-for-Value"],[54,"impl-Deserializer%3C\'de%3E-for-%26Value"],[55,"impl-Deserializer%3C\'de%3E-for-Value"],[57,"impl-Deserializer%3C\'de%3E-for-%26Value"],[58,"impl-Deserializer%3C\'de%3E-for-Value"],[60,"impl-Deserializer%3C\'de%3E-for-Value"],[61,"impl-Deserializer%3C\'de%3E-for-%26Value"],[63,"impl-Deserializer%3C\'de%3E-for-%26Value"],[64,"impl-Deserializer%3C\'de%3E-for-Value"],[66,"impl-Deserializer%3C\'de%3E-for-Value"],[67,"impl-Deserializer%3C\'de%3E-for-%26Value"],[69,"impl-Deserializer%3C\'de%3E-for-%26Value"],[70,"impl-Deserializer%3C\'de%3E-for-Value"],[72,"impl-Deserializer%3C\'de%3E-for-Value"],[73,"impl-Deserializer%3C\'de%3E-for-%26Value"],[75,"impl-Deserializer%3C\'de%3E-for-Value"],[76,"impl-Deserializer%3C\'de%3E-for-%26Value"],[78,"impl-Deserializer%3C\'de%3E-for-%26Value"],[79,"impl-Deserializer%3C\'de%3E-for-Value"],[81,"impl-Deserializer%3C\'de%3E-for-%26Value"],[82,"impl-Deserializer%3C\'de%3E-for-Value"],[84,"impl-Deserializer%3C\'de%3E-for-%26Value"],[85,"impl-Deserializer%3C\'de%3E-for-Value"],[87,"impl-Deserializer%3C\'de%3E-for-%26Value"],[88,"impl-Deserializer%3C\'de%3E-for-Value"],[90,"impl-Deserializer%3C\'de%3E-for-%26Value"],[91,"impl-Deserializer%3C\'de%3E-for-Value"],[93,"impl-Deserializer%3C\'de%3E-for-Value"],[94,"impl-Deserializer%3C\'de%3E-for-%26Value"],[96,"impl-Deserializer%3C\'de%3E-for-%26Value"],[97,"impl-Deserializer%3C\'de%3E-for-Value"],[99,"impl-Deserializer%3C\'de%3E-for-%26Value"],[100,"impl-Deserializer%3C\'de%3E-for-Value"],[102,"impl-Deserializer%3C\'de%3E-for-%26Value"],[103,"impl-Deserializer%3C\'de%3E-for-Value"],[105,"impl-Deserializer%3C\'de%3E-for-%26Value"],[106,"impl-Deserializer%3C\'de%3E-for-Value"],[108,"impl-Deserializer%3C\'de%3E-for-Value"],[109,"impl-Deserializer%3C\'de%3E-for-%26Value"],[111,"impl-Deserializer%3C\'de%3E-for-%26Value"],[112,"impl-Deserializer%3C\'de%3E-for-Value"],[114,"impl-Deserializer%3C\'de%3E-for-%26Value"],[115,"impl-Deserializer%3C\'de%3E-for-Value"],[117,"impl-Deserializer%3C\'de%3E-for-Value"],[118,"impl-Deserializer%3C\'de%3E-for-%26Value"],[120,"impl-Deserializer%3C\'de%3E-for-%26Value"],[121,"impl-Deserializer%3C\'de%3E-for-Value"],[123,"impl-Deserializer%3C\'de%3E-for-Value"],[124,"impl-Deserializer%3C\'de%3E-for-%26Value"],[126,"impl-Deserializer%3C\'de%3E-for-Value"],[127,"impl-Deserializer%3C\'de%3E-for-%26Value"],[129,"impl-Deserializer%3C\'de%3E-for-Value"],[130,"impl-Deserializer%3C\'de%3E-for-%26Value"],[132,"impl-Deserializer%3C\'de%3E-for-Value"],[133,"impl-Deserializer%3C\'de%3E-for-%26Value"],[135,"impl-PartialEq%3Cf32%3E-for-%26mut+Value"],[136,"impl-PartialEq%3Cu64%3E-for-%26Value"],[137,"impl-PartialEq%3Ci64%3E-for-Value"],[138,"impl-PartialEq%3Ci32%3E-for-Value"],[139,"impl-PartialEq%3Ci64%3E-for-%26Value"],[140,"impl-PartialEq%3Ci16%3E-for-%26mut+Value"],[141,"impl-PartialEq%3Cusize%3E-for-%26Value"],[142,"impl-PartialEq%3Cu16%3E-for-%26mut+Value"],[143,"impl-PartialEq%3Cusize%3E-for-%26mut+Value"],[144,"impl-PartialEq%3Cu16%3E-for-Value"],[145,"impl-PartialEq%3Cbool%3E-for-%26mut+Value"],[146,"impl-PartialEq%3CString%3E-for-Value"],[147,"impl-PartialEq%3Cu16%3E-for-%26Value"],[148,"impl-PartialEq%3Cu8%3E-for-%26Value"],[149,"impl-PartialEq%3Cf64%3E-for-%26mut+Value"],[150,"impl-PartialEq-for-Value"],[151,"impl-PartialEq%3Ci32%3E-for-%26Value"],[152,"impl-PartialEq%3Cf64%3E-for-%26Value"],[153,"impl-PartialEq%3Ci64%3E-for-%26mut+Value"],[154,"impl-PartialEq%3Ci32%3E-for-%26mut+Value"],[155,"impl-PartialEq%3Cusize%3E-for-Value"],[156,"impl-PartialEq%3Cu32%3E-for-Value"],[157,"impl-PartialEq%3Ci8%3E-for-%26mut+Value"],[158,"impl-PartialEq%3Cu32%3E-for-%26Value"],[159,"impl-PartialEq%3Cf32%3E-for-Value"],[160,"impl-PartialEq%3Cisize%3E-for-%26mut+Value"],[161,"impl-PartialEq%3Cf32%3E-for-%26Value"],[162,"impl-PartialEq%3Cu64%3E-for-Value"],[163,"impl-PartialEq%3Cu8%3E-for-Value"],[164,"impl-PartialEq%3Cbool%3E-for-Value"],[165,"impl-PartialEq%3Cstr%3E-for-Value"],[166,"impl-PartialEq%3Cisize%3E-for-Value"],[167,"impl-PartialEq%3Ci8%3E-for-Value"],[168,"impl-PartialEq%3Ci8%3E-for-%26Value"],[169,"impl-PartialEq%3Cu32%3E-for-%26mut+Value"],[170,"impl-PartialEq%3Cf64%3E-for-Value"],[171,"impl-PartialEq%3Cisize%3E-for-%26Value"],[172,"impl-PartialEq%3Ci16%3E-for-Value"],[173,"impl-PartialEq%3Cu64%3E-for-%26mut+Value"],[174,"impl-PartialEq%3Cbool%3E-for-%26Value"],[175,"impl-PartialEq%3C%26str%3E-for-Value"],[176,"impl-PartialEq%3Ci16%3E-for-%26Value"],[177,"impl-PartialEq%3Cu8%3E-for-%26mut+Value"],[180,"impl-Debug-for-Error"],[181,"impl-Display-for-Error"],[183,"impl-Display-for-Value"],[184,"impl-Debug-for-Value"],[190,"impl-From%3Cu8%3E-for-Value"],[191,"impl-From%3Cf64%3E-for-Value"],[192,"impl-From%3Ci8%3E-for-Value"],[193,"impl-From%3Cusize%3E-for-Value"],[194,"impl-From%3Ci64%3E-for-Value"],[196,"impl-From%3Cu32%3E-for-Value"],[197,"impl-From%3C()%3E-for-Value"],[198,"impl-From%3Cf32%3E-for-Value"],[199,"impl-From%3Cbool%3E-for-Value"],[200,"impl-From%3Cisize%3E-for-Value"],[201,"impl-From%3CString%3E-for-Value"],[202,"impl-From%3CCow%3C\'a,+str%3E%3E-for-Value"],[203,"impl-From%3Cu64%3E-for-Value"],[204,"impl-From%3Ci32%3E-for-Value"],[205,"impl-From%3C%26str%3E-for-Value"],[206,"impl-From%3CMap%3CString,+Value%3E%3E-for-Value"],[207,"impl-From%3C%26%5BT%5D%3E-for-Value"],[208,"impl-From%3COption%3CT%3E%3E-for-Value"],[209,"impl-From%3Ci16%3E-for-Value"],[210,"impl-From%3CVec%3CT%3E%3E-for-Value"],[211,"impl-From%3CNumber%3E-for-Value"],[212,"impl-From%3Cu16%3E-for-Value"],[214,"impl-FromIterator%3C(K,+V)%3E-for-Value"],[215,"impl-FromIterator%3CT%3E-for-Value"],[231,"impl-IntoDeserializer%3C\'de,+Error%3E-for-%26Value"],[232,"impl-IntoDeserializer%3C\'de,+Error%3E-for-Value"],[234,"impl-IntoIterator-for-%26Map%3CString,+Value%3E"],[235,"impl-IntoIterator-for-Map%3CString,+Value%3E"],[236,"impl-IntoIterator-for-%26mut+Map%3CString,+Value%3E"],[642,"impl-Deserializer%3C\'de%3E-for-%26Number"],[643,"impl-Deserializer%3C\'de%3E-for-Number"],[644,"impl-Deserializer%3C\'de%3E-for-%26Number"],[645,"impl-Deserializer%3C\'de%3E-for-Number"],[646,"impl-Deserializer%3C\'de%3E-for-Number"],[647,"impl-Deserializer%3C\'de%3E-for-%26Number"],[648,"impl-Deserializer%3C\'de%3E-for-Number"],[649,"impl-Deserializer%3C\'de%3E-for-%26Number"],[650,"impl-Deserializer%3C\'de%3E-for-Number"],[651,"impl-Deserializer%3C\'de%3E-for-%26Number"],[652,"impl-Deserializer%3C\'de%3E-for-Number"],[653,"impl-Deserializer%3C\'de%3E-for-%26Number"],[654,"impl-Deserializer%3C\'de%3E-for-Number"],[655,"impl-Deserializer%3C\'de%3E-for-%26Number"],[656,"impl-Deserializer%3C\'de%3E-for-Number"],[657,"impl-Deserializer%3C\'de%3E-for-%26Number"],[658,"impl-Deserializer%3C\'de%3E-for-Number"],[659,"impl-Deserializer%3C\'de%3E-for-%26Number"],[660,"impl-Deserializer%3C\'de%3E-for-%26Number"],[661,"impl-Deserializer%3C\'de%3E-for-Number"],[662,"impl-Deserializer%3C\'de%3E-for-%26Number"],[663,"impl-Deserializer%3C\'de%3E-for-Number"],[664,"impl-Deserializer%3C\'de%3E-for-%26Number"],[665,"impl-Deserializer%3C\'de%3E-for-Number"],[666,"impl-Deserializer%3C\'de%3E-for-%26Number"],[667,"impl-Deserializer%3C\'de%3E-for-Number"],[668,"impl-Deserializer%3C\'de%3E-for-Number"],[669,"impl-Deserializer%3C\'de%3E-for-%26Number"],[670,"impl-Deserializer%3C\'de%3E-for-Number"],[671,"impl-Deserializer%3C\'de%3E-for-%26Number"],[672,"impl-Deserializer%3C\'de%3E-for-%26Number"],[673,"impl-Deserializer%3C\'de%3E-for-Number"],[674,"impl-Deserializer%3C\'de%3E-for-%26Number"],[675,"impl-Deserializer%3C\'de%3E-for-Number"],[676,"impl-Deserializer%3C\'de%3E-for-Number"],[677,"impl-Deserializer%3C\'de%3E-for-%26Number"],[678,"impl-Deserializer%3C\'de%3E-for-%26Number"],[679,"impl-Deserializer%3C\'de%3E-for-Number"],[680,"impl-Deserializer%3C\'de%3E-for-Number"],[681,"impl-Deserializer%3C\'de%3E-for-%26Number"],[682,"impl-Deserializer%3C\'de%3E-for-Number"],[683,"impl-Deserializer%3C\'de%3E-for-%26Number"],[684,"impl-Deserializer%3C\'de%3E-for-%26Number"],[685,"impl-Deserializer%3C\'de%3E-for-Number"],[686,"impl-Deserializer%3C\'de%3E-for-%26Number"],[687,"impl-Deserializer%3C\'de%3E-for-Number"],[688,"impl-Deserializer%3C\'de%3E-for-Number"],[689,"impl-Deserializer%3C\'de%3E-for-%26Number"],[690,"impl-Deserializer%3C\'de%3E-for-%26Number"],[691,"impl-Deserializer%3C\'de%3E-for-Number"],[692,"impl-Deserializer%3C\'de%3E-for-Number"],[693,"impl-Deserializer%3C\'de%3E-for-%26Number"],[694,"impl-Deserializer%3C\'de%3E-for-Number"],[695,"impl-Deserializer%3C\'de%3E-for-%26Number"],[696,"impl-Deserializer%3C\'de%3E-for-%26Number"],[697,"impl-Deserializer%3C\'de%3E-for-Number"],[698,"impl-Deserializer%3C\'de%3E-for-Number"],[699,"impl-Deserializer%3C\'de%3E-for-%26Number"],[700,"impl-Deserializer%3C\'de%3E-for-%26Number"],[701,"impl-Deserializer%3C\'de%3E-for-Number"],[702,"impl-Deserializer%3C\'de%3E-for-%26Number"],[703,"impl-Deserializer%3C\'de%3E-for-Number"],[705,"impl-Debug-for-Number"],[706,"impl-Display-for-Number"],[709,"impl-From%3Ci8%3E-for-Number"],[710,"impl-From%3Ci64%3E-for-Number"],[711,"impl-From%3Cu32%3E-for-Number"],[712,"impl-From%3Cu16%3E-for-Number"],[713,"impl-From%3Cisize%3E-for-Number"],[714,"impl-From%3Cu64%3E-for-Number"],[715,"impl-From%3Ci32%3E-for-Number"],[716,"impl-From%3Cu8%3E-for-Number"],[717,"impl-From%3Cusize%3E-for-Number"],[718,"impl-From%3Ci16%3E-for-Number"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAPEBOAARABMAJgAMADQABAA6AB8AWwABAF4AVAC0AAMAuQAAAL8AAADBAAIAxQAAAMkAAADMAAEA0QABANUAAQDcAAAA3gAAAOAAAADoAAcA8gAAAPQADAACARQAGAEBACABEQA5AQUAUwEIAGUBAQBoAQEAawEBAHUBAwCHAREAtgEFAMUBBQDMAQsA3gEgABECAAATAgAAFQIAABcCAAAZAgAAGwIKACcCAAApAgAAKwIAAC4CAAAwAgEAPAIBAEQCCABlAgAAewJIAMYCCQDRAgAA1QIAAOYCHgAGAwEACQMFAA=="}],\ diff --git a/docs/rust/serde/de/value/struct.CowStrDeserializer.html b/docs/rust/serde/de/value/struct.CowStrDeserializer.html index 254d1865891..f32174493a8 100644 --- a/docs/rust/serde/de/value/struct.CowStrDeserializer.html +++ b/docs/rust/serde/de/value/struct.CowStrDeserializer.html @@ -1,6 +1,6 @@ CowStrDeserializer in serde::de::value - Rust

Struct serde::de::value::CowStrDeserializer

source · 
pub struct CowStrDeserializer<'a, E> { /* private fields */ }
Expand description

A deserializer holding a Cow<str>.

Implementations§

source§

impl<'a, E> CowStrDeserializer<'a, E>

source

pub fn new(value: Cow<'a, str>) -> Self

Trait Implementations§

source§

impl<'a, E> Clone for CowStrDeserializer<'a, E>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<'a, E> Debug for CowStrDeserializer<'a, E>

source§

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<'de, 'a, E> Deserializer<'de> for CowStrDeserializer<'a, E>
where - E: Error,

§

type Error = E

The error type that can be returned if some error occurs during + E: Error,
§

type Error = E

The error type that can be returned if some error occurs during deserialization.
source§

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input. Read more
source§

fn deserialize_enum<V>( @@ -150,7 +150,7 @@ V: Visitor<'de>,

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored. Read more
source§

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form. Read more
source§

impl<'de, 'a, E> EnumAccess<'de> for CowStrDeserializer<'a, E>
where - E: Error,

§

type Error = E

The error type that can be returned if some error occurs during + E: Error,
§

type Error = E

The error type that can be returned if some error occurs during deserialization.
§

type Variant = UnitOnly<E>

The Visitor that will be used to deserialize the content of the enum variant.
source§

fn variant_seed<T>( self, diff --git a/docs/rust/serde/de/value/struct.Error.html b/docs/rust/serde/de/value/struct.Error.html index 89ee463bd81..2e21a3e94a1 100644 --- a/docs/rust/serde/de/value/struct.Error.html +++ b/docs/rust/serde/de/value/struct.Error.html @@ -1,8 +1,8 @@ Error in serde::de::value - Rust

Struct serde::de::value::Error

source · 
pub struct Error { /* private fields */ }
Expand description

A minimal representation of all possible errors that can occur using the IntoDeserializer trait.

-

Trait Implementations§

source§

impl Clone for Error

source§

fn clone(&self) -> Error

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Error

source§

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Display for Error

source§

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Error for Error

source§

fn custom<T>(msg: T) -> Self
where +

Trait Implementations§

source§

impl Clone for Error

source§

fn clone(&self) -> Error

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Error

source§

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Display for Error

source§

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Error for Error

source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl Error for Error

source§

fn custom<T>(msg: T) -> Self
where T: Display,

Used when a Serialize implementation encounters any error -while serializing a type. Read more
source§

impl Error for Error

source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl Error for Error

source§

fn custom<T>(msg: T) -> Self
where +while serializing a type. Read more

source§

impl Error for Error

source§

fn custom<T>(msg: T) -> Self
where T: Display,

Raised when there is general error when deserializing a type. Read more
source§

fn invalid_type(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self

Raised when a Deserialize receives a type different from what it was expecting. Read more
source§

fn invalid_value(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self

Raised when a Deserialize receives a value of the right type but that is wrong for some other reason. Read more
source§

fn invalid_length(len: usize, exp: &dyn Expected) -> Self

Raised when deserializing a sequence or map and the input data contains diff --git a/docs/rust/serde/de/value/struct.MapAccessDeserializer.html b/docs/rust/serde/de/value/struct.MapAccessDeserializer.html index ac0a84c1755..0e0f66a38af 100644 --- a/docs/rust/serde/de/value/struct.MapAccessDeserializer.html +++ b/docs/rust/serde/de/value/struct.MapAccessDeserializer.html @@ -1,7 +1,7 @@ MapAccessDeserializer in serde::de::value - Rust

Struct serde::de::value::MapAccessDeserializer

source · 
pub struct MapAccessDeserializer<A> { /* private fields */ }
Expand description

A deserializer holding a MapAccess.

Implementations§

source§

impl<A> MapAccessDeserializer<A>

source

pub fn new(map: A) -> Self

Construct a new MapAccessDeserializer<A>.

Trait Implementations§

source§

impl<A: Clone> Clone for MapAccessDeserializer<A>

source§

fn clone(&self) -> MapAccessDeserializer<A>

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<A: Debug> Debug for MapAccessDeserializer<A>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<'de, A> Deserializer<'de> for MapAccessDeserializer<A>
where - A: MapAccess<'de>,

§

type Error = <A as MapAccess<'de>>::Error

The error type that can be returned if some error occurs during + A: MapAccess<'de>,

§

type Error = <A as MapAccess<'de>>::Error

The error type that can be returned if some error occurs during deserialization.
source§

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input. Read more
source§

fn deserialize_enum<V>( @@ -151,7 +151,7 @@ V: Visitor<'de>,

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored. Read more
source§

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form. Read more
source§

impl<'de, A> EnumAccess<'de> for MapAccessDeserializer<A>
where - A: MapAccess<'de>,

§

type Error = <A as MapAccess<'de>>::Error

The error type that can be returned if some error occurs during + A: MapAccess<'de>,
§

type Error = <A as MapAccess<'de>>::Error

The error type that can be returned if some error occurs during deserialization.
§

type Variant = MapAsEnum<A>

The Visitor that will be used to deserialize the content of the enum variant.
source§

fn variant_seed<T>( self, diff --git a/docs/rust/serde/de/value/struct.MapDeserializer.html b/docs/rust/serde/de/value/struct.MapDeserializer.html index a3e3f722548..da196f34a05 100644 --- a/docs/rust/serde/de/value/struct.MapDeserializer.html +++ b/docs/rust/serde/de/value/struct.MapDeserializer.html @@ -20,7 +20,7 @@ I::Item: Pair, <I::Item as Pair>::First: IntoDeserializer<'de, E>, <I::Item as Pair>::Second: IntoDeserializer<'de, E>, - E: Error,

§

type Error = E

The error type that can be returned if some error occurs during + E: Error,
§

type Error = E

The error type that can be returned if some error occurs during deserialization.
source§

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input. Read more
source§

fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where @@ -171,7 +171,7 @@ I::Item: Pair, <I::Item as Pair>::First: IntoDeserializer<'de, E>, <I::Item as Pair>::Second: IntoDeserializer<'de, E>, - E: Error,

§

type Error = E

The error type that can be returned if some error occurs during + E: Error,
§

type Error = E

The error type that can be returned if some error occurs during deserialization.
source§

fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: DeserializeSeed<'de>,

This returns Ok(Some(key)) for the next key in the map, or Ok(None) if there are no more remaining entries. Read more
source§

fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
where @@ -182,7 +182,7 @@ ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
where TK: DeserializeSeed<'de>, TV: 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. Read more
source§

fn size_hint(&self) -> Option<usize>

Returns the number of entries remaining in the map, if known.
source§

fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>
where +the map, or Ok(None) if there are no more remaining items. Read more

source§

fn size_hint(&self) -> Option<usize>

Returns the number of entries remaining in the map, if known.
source§

fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>
where K: Deserialize<'de>,

This returns Ok(Some(key)) for the next key in the map, or Ok(None) if there are no more remaining entries. Read more
source§

fn next_value<V>(&mut self) -> Result<V, Self::Error>
where V: Deserialize<'de>,

This returns a Ok(value) for the next value in the map. Read more
source§

fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
where @@ -199,7 +199,7 @@ 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. Read more
source§

fn size_hint(&self) -> Option<usize>

Returns the number of elements remaining in the sequence, if known.
source§

fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
where +Ok(None) if there are no more remaining items. Read more

source§

fn size_hint(&self) -> Option<usize>

Returns the number of elements remaining in the sequence, if known.
source§

fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
where T: Deserialize<'de>,

This returns Ok(Some(value)) for the next value in the sequence, or Ok(None) if there are no more remaining items. Read more

Auto Trait Implementations§

§

impl<'de, I, E> Freeze for MapDeserializer<'de, I, E>
where <<I as Iterator>::Item as Pair>::Second: Freeze, diff --git a/docs/rust/serde/de/value/struct.StringDeserializer.html b/docs/rust/serde/de/value/struct.StringDeserializer.html index de73a6634ad..0bb9398fb20 100644 --- a/docs/rust/serde/de/value/struct.StringDeserializer.html +++ b/docs/rust/serde/de/value/struct.StringDeserializer.html @@ -1,6 +1,6 @@ StringDeserializer in serde::de::value - Rust

Struct serde::de::value::StringDeserializer

source · 
pub struct StringDeserializer<E> { /* private fields */ }
Expand description

A deserializer holding a String.

Implementations§

source§

impl<E> StringDeserializer<E>

source

pub fn new(value: String) -> Self

Trait Implementations§

source§

impl<E> Clone for StringDeserializer<E>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<E> Debug for StringDeserializer<E>

source§

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<'de, E> Deserializer<'de> for StringDeserializer<E>
where - E: Error,

§

type Error = E

The error type that can be returned if some error occurs during + E: Error,

§

type Error = E

The error type that can be returned if some error occurs during deserialization.
source§

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input. Read more
source§

fn deserialize_enum<V>( @@ -150,7 +150,7 @@ V: Visitor<'de>,

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored. Read more
source§

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form. Read more
source§

impl<'de, E> EnumAccess<'de> for StringDeserializer<E>
where - E: Error,

§

type Error = E

The error type that can be returned if some error occurs during + E: Error,
§

type Error = E

The error type that can be returned if some error occurs during deserialization.
§

type Variant = UnitOnly<E>

The Visitor that will be used to deserialize the content of the enum variant.
source§

fn variant_seed<T>( self, diff --git a/docs/rust/serde/ser/struct.Impossible.html b/docs/rust/serde/ser/struct.Impossible.html index e7e97fd3920..20594592ea1 100644 --- a/docs/rust/serde/ser/struct.Impossible.html +++ b/docs/rust/serde/ser/struct.Impossible.html @@ -24,35 +24,35 @@ /* other Serializer methods */ }

Trait Implementations§

source§

impl<Ok, Error> SerializeMap for Impossible<Ok, Error>
where - Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
where + Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
where T: ?Sized + Serialize,

Serialize a map key. Read more
source§

fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
where - T: ?Sized + Serialize,

Serialize a map value. Read more
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a map.
source§

fn serialize_entry<K, V>( + T: ?Sized + Serialize,

Serialize a map value. Read more
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a map.
source§

fn serialize_entry<K, V>( &mut self, key: &K, value: &V ) -> Result<(), Self::Error>
where K: ?Sized + Serialize, V: ?Sized + Serialize,

Serialize a map entry consisting of a key and a value. Read more
source§

impl<Ok, Error> SerializeSeq for Impossible<Ok, Error>
where - Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
where - T: ?Sized + Serialize,

Serialize a sequence element.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a sequence.
source§

impl<Ok, Error> SerializeStruct for Impossible<Ok, Error>
where - Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_field<T>( + Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
where + T: ?Sized + Serialize,

Serialize a sequence element.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a sequence.
source§

impl<Ok, Error> SerializeStruct for Impossible<Ok, Error>
where + Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_field<T>( &mut self, key: &'static str, value: &T ) -> Result<(), Error>
where - T: ?Sized + Serialize,

Serialize a struct field.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a struct.
source§

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct field has been skipped. Read more
source§

impl<Ok, Error> SerializeStructVariant for Impossible<Ok, Error>
where - Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_field<T>( + T: ?Sized + Serialize,

Serialize a struct field.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a struct.
source§

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct field has been skipped. Read more
source§

impl<Ok, Error> SerializeStructVariant for Impossible<Ok, Error>
where + Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_field<T>( &mut self, key: &'static str, value: &T ) -> Result<(), Error>
where - T: ?Sized + Serialize,

Serialize a struct variant field.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a struct variant.
source§

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct variant field has been skipped. Read more
source§

impl<Ok, Error> SerializeTuple for Impossible<Ok, Error>
where - Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
where - T: ?Sized + Serialize,

Serialize a tuple element.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a tuple.
source§

impl<Ok, Error> SerializeTupleStruct for Impossible<Ok, Error>
where + T: ?Sized + Serialize,

Serialize a struct variant field.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a struct variant.
source§

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct variant field has been skipped. Read more
source§

impl<Ok, Error> SerializeTuple for Impossible<Ok, Error>
where + Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
where + T: ?Sized + Serialize,

Serialize a tuple element.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a tuple.
source§

impl<Ok, Error> SerializeTupleStruct for Impossible<Ok, Error>
where Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
where T: ?Sized + Serialize,

Serialize a tuple struct field.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a tuple struct.
source§

impl<Ok, Error> SerializeTupleVariant for Impossible<Ok, Error>
where - Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
where - T: ?Sized + Serialize,

Serialize a tuple variant field.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a tuple variant.

Auto Trait Implementations§

§

impl<Ok, Error> Freeze for Impossible<Ok, Error>

§

impl<Ok, Error> RefUnwindSafe for Impossible<Ok, Error>
where + Error: Error,

§

type Ok = Ok

Must match the Ok type of our Serializer.
§

type Error = Error

Must match the Error type of our Serializer.
source§

fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
where + T: ?Sized + Serialize,

Serialize a tuple variant field.
source§

fn end(self) -> Result<Ok, Error>

Finish serializing a tuple variant.

Auto Trait Implementations§

§

impl<Ok, Error> Freeze for Impossible<Ok, Error>

§

impl<Ok, Error> RefUnwindSafe for Impossible<Ok, Error>
where Ok: RefUnwindSafe, Error: RefUnwindSafe,

§

impl<Ok, Error> Send for Impossible<Ok, Error>
where Ok: Send, diff --git a/docs/rust/shadow_build_info/constant.BUILD_TIMESTAMP.html b/docs/rust/shadow_build_info/constant.BUILD_TIMESTAMP.html index 7829183f66c..cb3557ffe85 100644 --- a/docs/rust/shadow_build_info/constant.BUILD_TIMESTAMP.html +++ b/docs/rust/shadow_build_info/constant.BUILD_TIMESTAMP.html @@ -1 +1 @@ -BUILD_TIMESTAMP in shadow_build_info - Rust

Constant shadow_build_info::BUILD_TIMESTAMP

source · 
pub const BUILD_TIMESTAMP: &str = "2024-06-29--00:39:45";
\ No newline at end of file +BUILD_TIMESTAMP in shadow_build_info - Rust

Constant shadow_build_info::BUILD_TIMESTAMP

source · 
pub const BUILD_TIMESTAMP: &str = "2024-06-30--00:44:42";
\ No newline at end of file diff --git a/docs/rust/type.impl/core/result/enum.Result.js b/docs/rust/type.impl/core/result/enum.Result.js index 7b23c868f5a..c3280d86636 100644 --- a/docs/rust/type.impl/core/result/enum.Result.js +++ b/docs/rust/type.impl/core/result/enum.Result.js @@ -1,7 +1,7 @@ (function() {var type_impls = { "anyhow":[["
1.0.0 · source§

impl<T, E> Clone for Result<T, E>
where\n T: Clone,\n E: Clone,

source§

fn clone(&self) -> Result<T, E>

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Result<T, E>)

Performs copy-assignment from source. Read more
","Clone","anyhow::Result"],["
source§

impl<T, E> Context<T, E> for Result<T, E>
where\n E: StdError + Send + Sync + 'static,

source§

fn context<C>(self, context: C) -> Result<T, Error>
where\n C: Display + Send + Sync + 'static,

Wrap the error value with additional context.
source§

fn with_context<C, F>(self, context: F) -> Result<T, Error>
where\n C: Display + Send + Sync + 'static,\n F: FnOnce() -> C,

Wrap the error value with additional context that is evaluated lazily\nonly once an error does occur.
","Context","anyhow::Result"],["
1.0.0 · source§

impl<T, E> Debug for Result<T, E>
where\n T: Debug,\n E: Debug,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
","Debug","anyhow::Result"],["
source§

impl From<&StreamResult> for Result<MZStatus, MZError>

source§

fn from(res: &StreamResult) -> Result<MZStatus, MZError>

Converts to this type from the input type.
","From<&StreamResult>","anyhow::Result"],["
source§

impl From<StreamResult> for Result<MZStatus, MZError>

source§

fn from(res: StreamResult) -> Result<MZStatus, MZError>

Converts to this type from the input type.
","From","anyhow::Result"],["
1.0.0 · source§

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
where\n V: FromIterator<A>,

source§

fn from_iter<I>(iter: I) -> Result<V, E>
where\n I: IntoIterator<Item = Result<A, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.

\n

Here is an example which increments every integer in a vector,\nchecking for overflow:

\n\n
let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
\n

Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:

\n\n
let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
\n

Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.

\n\n
let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
\n

Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.

\n
","FromIterator>","anyhow::Result"],["
source§

impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","anyhow::Result"],["
source§

impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(_: Yeet<E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","anyhow::Result"],["
1.0.0 · source§

impl<T, E> Hash for Result<T, E>
where\n T: Hash,\n E: Hash,

source§

fn hash<__H>(&self, state: &mut __H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","anyhow::Result"],["
1.0.0 · source§

impl<T, E> IntoIterator for Result<T, E>

source§

fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
","IntoIterator","anyhow::Result"],["
1.0.0 · source§

impl<T, E> Ord for Result<T, E>
where\n T: Ord,\n E: Ord,

source§

fn cmp(&self, other: &Result<T, E>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","anyhow::Result"],["
1.0.0 · source§

impl<T, E> PartialEq for Result<T, E>
where\n T: PartialEq,\n E: PartialEq,

source§

fn eq(&self, other: &Result<T, E>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","anyhow::Result"],["
1.0.0 · source§

impl<T, E> PartialOrd for Result<T, E>
where\n T: PartialOrd,\n E: PartialOrd,

source§

fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","anyhow::Result"],["
1.16.0 · source§

impl<T, U, E> Product<Result<U, E>> for Result<T, E>
where\n T: Product<U>,

source§

fn product<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.

\n
§Examples
\n

This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:

\n\n
let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
\n
","Product>","anyhow::Result"],["
source§

impl<T, E> Residual<T> for Result<Infallible, E>

§

type TryType = Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2_residual)
The “return” type of this meta-function.
","Residual","anyhow::Result"],["
source§

impl<T, E> Result<&T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"anyhow::Result"],["
source§

impl<T, E> Result<&mut T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&mut T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&mut T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"anyhow::Result"],["
source§

impl<T, E> Result<Option<T>, E>

1.33.0 (const: unstable) · source

pub fn transpose(self) -> Option<Result<T, E>>

Transposes a Result of an Option into an Option of a Result.

\n

Ok(None) will be mapped to None.\nOk(Some(_)) and Err(_) will be mapped to Some(Ok(_)) and Some(Err(_)).

\n
§Examples
\n
#[derive(Debug, Eq, PartialEq)]\nstruct SomeErr;\n\nlet x: Result<Option<i32>, SomeErr> = Ok(Some(5));\nlet y: Option<Result<i32, SomeErr>> = Some(Ok(5));\nassert_eq!(x.transpose(), y);
\n
",0,"anyhow::Result"],["
source§

impl<T, E> Result<Result<T, E>, E>

source

pub fn flatten(self) -> Result<T, E>

🔬This is a nightly-only experimental API. (result_flattening)

Converts from Result<Result<T, E>, E> to Result<T, E>

\n
§Examples
\n
#![feature(result_flattening)]\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Ok(\"hello\"));\nassert_eq!(Ok(\"hello\"), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));\nassert_eq!(Err(6), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Err(6);\nassert_eq!(Err(6), x.flatten());
\n

Flattening only removes one level of nesting at a time:

\n\n
#![feature(result_flattening)]\nlet x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok(\"hello\")));\nassert_eq!(Ok(Ok(\"hello\")), x.flatten());\nassert_eq!(Ok(\"hello\"), x.flatten().flatten());
\n
",0,"anyhow::Result"],["
source§

impl<T, E> Result<T, E>

1.0.0 (const: 1.48.0) · source

pub const fn is_ok(&self) -> bool

Returns true if the result is Ok.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
\n
1.70.0 · source

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

Returns true if the result is Ok and the value inside of it matches a predicate.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
\n
1.0.0 (const: 1.48.0) · source

pub const fn is_err(&self) -> bool

Returns true if the result is Err.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
\n
1.70.0 · source

pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool

Returns true if the result is Err and the value inside of it matches a predicate.

\n
§Examples
\n
use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
\n
1.0.0 · source

pub fn ok(self) -> Option<T>

Converts from Result<T, E> to Option<T>.

\n

Converts self into an Option<T>, consuming self,\nand discarding the error, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
\n
1.0.0 · source

pub fn err(self) -> Option<E>

Converts from Result<T, E> to Option<E>.

\n

Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
\n
1.0.0 (const: 1.48.0) · source

pub const fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

\n

Produces a new Result, containing a reference\ninto the original, leaving the original in place.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
\n
1.0.0 (const: unstable) · source

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

\n
§Examples
\n
fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
\n
1.0.0 · source

pub fn map<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> U,

Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.

\n

This function can be used to compose the results of two functions.

\n
§Examples
\n

Print the numbers on each line of a string multiplied by two.

\n\n
let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
\n
1.41.0 · source

pub fn map_or<U, F>(self, default: U, f: F) -> U
where\n F: FnOnce(T) -> U,

Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).

\n

Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
\n
1.41.0 · source

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where\n D: FnOnce(E) -> U,\n F: FnOnce(T) -> U,

Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.

\n

This function can be used to unpack a successful result\nwhile handling an error.

\n
§Examples
\n
let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
\n
1.0.0 · source

pub fn map_err<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> F,

Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.

\n

This function can be used to pass through a successful result while handling\nan error.

\n
§Examples
\n
fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
\n
1.76.0 · source

pub fn inspect<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&T),

Calls a function with a reference to the contained value if Ok.

\n

Returns the original result.

\n
§Examples
\n
let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
\n
1.76.0 · source

pub fn inspect_err<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&E),

Calls a function with a reference to the contained value if Err.

\n

Returns the original result.

\n
§Examples
\n
use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
\n
1.47.0 · source

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where\n T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

\n

Coerces the Ok variant of the original Result via Deref\nand returns the new Result.

\n
§Examples
\n
let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
\n
1.47.0 · source

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where\n T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

\n

Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.

\n
§Examples
\n
let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
\n
1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
\n
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
\n
1.4.0 · source

pub fn expect(self, msg: &str) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
\n
§Recommended Message Style
\n

We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.

\n\n
ⓘ
let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
\n

Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.

\n

For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.

\n
1.0.0 · source

pub fn unwrap(self) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message provided by the\nErr’s value.

\n
§Examples
\n

Basic usage:

\n\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
\n\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
\n
1.16.0 · source

pub fn unwrap_or_default(self) -> T
where\n T: Default,

Returns the contained Ok value or a default

\n

Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.

\n
§Examples
\n

Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.

\n\n
let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
\n
1.17.0 · source

pub fn expect_err(self, msg: &str) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
\n
1.0.0 · source

pub fn unwrap_err(self) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
\n
source

pub fn into_ok(self) -> T
where\n E: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Ok value, but never panics.

\n

Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.

\n
§Examples
\n
\nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
\n
source

pub fn into_err(self) -> E
where\n T: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Err value, but never panics.

\n

Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.

\n
§Examples
\n
\nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
\n
1.0.0 · source

pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>

Returns res if the result is Ok, otherwise returns the Err value of self.

\n

Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
\n
1.0.0 · source

pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> Result<U, E>,

Calls op if the result is Ok, otherwise returns the Err value of self.

\n

This function can be used for control flow based on Result values.

\n
§Examples
\n
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
\n

Often used to chain fallible operations that may return Err.

\n\n
use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
\n
1.0.0 · source

pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

Returns res if the result is Err, otherwise returns the Ok value of self.

\n

Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
\n
1.0.0 · source

pub fn or_else<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> Result<T, F>,

Calls op if the result is Err, otherwise returns the Ok value of self.

\n

This function can be used for control flow based on result values.

\n
§Examples
\n
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
\n
1.0.0 · source

pub fn unwrap_or(self, default: T) -> T

Returns the contained Ok value or a provided default.

\n

Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
\n
1.0.0 · source

pub fn unwrap_or_else<F>(self, op: F) -> T
where\n F: FnOnce(E) -> T,

Returns the contained Ok value or computes it from a closure.

\n
§Examples
\n
fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
\n
1.58.0 · source

pub unsafe fn unwrap_unchecked(self) -> T

Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.

\n
§Safety
\n

Calling this method on an Err is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
\n
1.58.0 · source

pub unsafe fn unwrap_err_unchecked(self) -> E

Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.

\n
§Safety
\n

Calling this method on an Ok is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
\n
",0,"anyhow::Result"],["
1.16.0 · source§

impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
where\n T: Sum<U>,

source§

fn sum<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.

\n
§Examples
\n

This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:

\n\n
let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
\n
","Sum>","anyhow::Result"],["
1.61.0 · source§

impl<T, E> Termination for Result<T, E>
where\n T: Termination,\n E: Debug,

source§

fn report(self) -> ExitCode

Is called to get the representation of the value as status code.\nThis status code is returned to the operating system.
","Termination","anyhow::Result"],["
source§

impl<T, E> Try for Result<T, E>

§

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value produced by ? when not short-circuiting.
§

type Residual = Result<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
source§

fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from its Output type. Read more
source§

fn branch(\n self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

🔬This is a nightly-only experimental API. (try_trait_v2)
Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
","Try","anyhow::Result"],["
1.0.0 · source§

impl<T, E> Copy for Result<T, E>
where\n T: Copy,\n E: Copy,

","Copy","anyhow::Result"],["
1.0.0 · source§

impl<T, E> Eq for Result<T, E>
where\n T: Eq,\n E: Eq,

","Eq","anyhow::Result"],["
1.0.0 · source§

impl<T, E> StructuralPartialEq for Result<T, E>

","StructuralPartialEq","anyhow::Result"]], "clap":[["
1.0.0 · source§

impl<T, E> Clone for Result<T, E>
where\n T: Clone,\n E: Clone,

source§

fn clone(&self) -> Result<T, E>

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Result<T, E>)

Performs copy-assignment from source. Read more
","Clone","clap::error::Result"],["
1.0.0 · source§

impl<T, E> Debug for Result<T, E>
where\n T: Debug,\n E: Debug,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
","Debug","clap::error::Result"],["
source§

impl From<&StreamResult> for Result<MZStatus, MZError>

source§

fn from(res: &StreamResult) -> Result<MZStatus, MZError>

Converts to this type from the input type.
","From<&StreamResult>","clap::error::Result"],["
source§

impl From<StreamResult> for Result<MZStatus, MZError>

source§

fn from(res: StreamResult) -> Result<MZStatus, MZError>

Converts to this type from the input type.
","From","clap::error::Result"],["
1.0.0 · source§

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
where\n V: FromIterator<A>,

source§

fn from_iter<I>(iter: I) -> Result<V, E>
where\n I: IntoIterator<Item = Result<A, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.

\n

Here is an example which increments every integer in a vector,\nchecking for overflow:

\n\n
let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
\n

Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:

\n\n
let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
\n

Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.

\n\n
let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
\n

Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.

\n
","FromIterator>","clap::error::Result"],["
source§

impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","clap::error::Result"],["
source§

impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(_: Yeet<E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","clap::error::Result"],["
1.0.0 · source§

impl<T, E> Hash for Result<T, E>
where\n T: Hash,\n E: Hash,

source§

fn hash<__H>(&self, state: &mut __H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","clap::error::Result"],["
1.0.0 · source§

impl<T, E> IntoIterator for Result<T, E>

source§

fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
","IntoIterator","clap::error::Result"],["
1.0.0 · source§

impl<T, E> Ord for Result<T, E>
where\n T: Ord,\n E: Ord,

source§

fn cmp(&self, other: &Result<T, E>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","clap::error::Result"],["
1.0.0 · source§

impl<T, E> PartialEq for Result<T, E>
where\n T: PartialEq,\n E: PartialEq,

source§

fn eq(&self, other: &Result<T, E>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","clap::error::Result"],["
1.0.0 · source§

impl<T, E> PartialOrd for Result<T, E>
where\n T: PartialOrd,\n E: PartialOrd,

source§

fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","clap::error::Result"],["
1.16.0 · source§

impl<T, U, E> Product<Result<U, E>> for Result<T, E>
where\n T: Product<U>,

source§

fn product<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.

\n
§Examples
\n

This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:

\n\n
let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
\n
","Product>","clap::error::Result"],["
source§

impl<T, E> Residual<T> for Result<Infallible, E>

§

type TryType = Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2_residual)
The “return” type of this meta-function.
","Residual","clap::error::Result"],["
source§

impl<T, E> Result<&T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"clap::error::Result"],["
source§

impl<T, E> Result<&mut T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&mut T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&mut T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"clap::error::Result"],["
source§

impl<T, E> Result<Option<T>, E>

1.33.0 (const: unstable) · source

pub fn transpose(self) -> Option<Result<T, E>>

Transposes a Result of an Option into an Option of a Result.

\n

Ok(None) will be mapped to None.\nOk(Some(_)) and Err(_) will be mapped to Some(Ok(_)) and Some(Err(_)).

\n
§Examples
\n
#[derive(Debug, Eq, PartialEq)]\nstruct SomeErr;\n\nlet x: Result<Option<i32>, SomeErr> = Ok(Some(5));\nlet y: Option<Result<i32, SomeErr>> = Some(Ok(5));\nassert_eq!(x.transpose(), y);
\n
",0,"clap::error::Result"],["
source§

impl<T, E> Result<Result<T, E>, E>

source

pub fn flatten(self) -> Result<T, E>

🔬This is a nightly-only experimental API. (result_flattening)

Converts from Result<Result<T, E>, E> to Result<T, E>

\n
§Examples
\n
#![feature(result_flattening)]\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Ok(\"hello\"));\nassert_eq!(Ok(\"hello\"), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));\nassert_eq!(Err(6), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Err(6);\nassert_eq!(Err(6), x.flatten());
\n

Flattening only removes one level of nesting at a time:

\n\n
#![feature(result_flattening)]\nlet x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok(\"hello\")));\nassert_eq!(Ok(Ok(\"hello\")), x.flatten());\nassert_eq!(Ok(\"hello\"), x.flatten().flatten());
\n
",0,"clap::error::Result"],["
source§

impl<T, E> Result<T, E>

1.0.0 (const: 1.48.0) · source

pub const fn is_ok(&self) -> bool

Returns true if the result is Ok.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
\n
1.70.0 · source

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

Returns true if the result is Ok and the value inside of it matches a predicate.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
\n
1.0.0 (const: 1.48.0) · source

pub const fn is_err(&self) -> bool

Returns true if the result is Err.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
\n
1.70.0 · source

pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool

Returns true if the result is Err and the value inside of it matches a predicate.

\n
§Examples
\n
use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
\n
1.0.0 · source

pub fn ok(self) -> Option<T>

Converts from Result<T, E> to Option<T>.

\n

Converts self into an Option<T>, consuming self,\nand discarding the error, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
\n
1.0.0 · source

pub fn err(self) -> Option<E>

Converts from Result<T, E> to Option<E>.

\n

Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
\n
1.0.0 (const: 1.48.0) · source

pub const fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

\n

Produces a new Result, containing a reference\ninto the original, leaving the original in place.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
\n
1.0.0 (const: unstable) · source

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

\n
§Examples
\n
fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
\n
1.0.0 · source

pub fn map<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> U,

Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.

\n

This function can be used to compose the results of two functions.

\n
§Examples
\n

Print the numbers on each line of a string multiplied by two.

\n\n
let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
\n
1.41.0 · source

pub fn map_or<U, F>(self, default: U, f: F) -> U
where\n F: FnOnce(T) -> U,

Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).

\n

Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
\n
1.41.0 · source

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where\n D: FnOnce(E) -> U,\n F: FnOnce(T) -> U,

Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.

\n

This function can be used to unpack a successful result\nwhile handling an error.

\n
§Examples
\n
let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
\n
1.0.0 · source

pub fn map_err<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> F,

Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.

\n

This function can be used to pass through a successful result while handling\nan error.

\n
§Examples
\n
fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
\n
1.76.0 · source

pub fn inspect<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&T),

Calls a function with a reference to the contained value if Ok.

\n

Returns the original result.

\n
§Examples
\n
let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
\n
1.76.0 · source

pub fn inspect_err<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&E),

Calls a function with a reference to the contained value if Err.

\n

Returns the original result.

\n
§Examples
\n
use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
\n
1.47.0 · source

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where\n T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

\n

Coerces the Ok variant of the original Result via Deref\nand returns the new Result.

\n
§Examples
\n
let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
\n
1.47.0 · source

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where\n T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

\n

Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.

\n
§Examples
\n
let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
\n
1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
\n
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
\n
1.4.0 · source

pub fn expect(self, msg: &str) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
\n
§Recommended Message Style
\n

We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.

\n\n
ⓘ
let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
\n

Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.

\n

For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.

\n
1.0.0 · source

pub fn unwrap(self) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message provided by the\nErr’s value.

\n
§Examples
\n

Basic usage:

\n\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
\n\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
\n
1.16.0 · source

pub fn unwrap_or_default(self) -> T
where\n T: Default,

Returns the contained Ok value or a default

\n

Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.

\n
§Examples
\n

Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.

\n\n
let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
\n
1.17.0 · source

pub fn expect_err(self, msg: &str) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
\n
1.0.0 · source

pub fn unwrap_err(self) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
\n
source

pub fn into_ok(self) -> T
where\n E: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Ok value, but never panics.

\n

Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.

\n
§Examples
\n
\nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
\n
source

pub fn into_err(self) -> E
where\n T: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Err value, but never panics.

\n

Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.

\n
§Examples
\n
\nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
\n
1.0.0 · source

pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>

Returns res if the result is Ok, otherwise returns the Err value of self.

\n

Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
\n
1.0.0 · source

pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> Result<U, E>,

Calls op if the result is Ok, otherwise returns the Err value of self.

\n

This function can be used for control flow based on Result values.

\n
§Examples
\n
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
\n

Often used to chain fallible operations that may return Err.

\n\n
use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
\n
1.0.0 · source

pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

Returns res if the result is Err, otherwise returns the Ok value of self.

\n

Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
\n
1.0.0 · source

pub fn or_else<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> Result<T, F>,

Calls op if the result is Err, otherwise returns the Ok value of self.

\n

This function can be used for control flow based on result values.

\n
§Examples
\n
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
\n
1.0.0 · source

pub fn unwrap_or(self, default: T) -> T

Returns the contained Ok value or a provided default.

\n

Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
\n
1.0.0 · source

pub fn unwrap_or_else<F>(self, op: F) -> T
where\n F: FnOnce(E) -> T,

Returns the contained Ok value or computes it from a closure.

\n
§Examples
\n
fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
\n
1.58.0 · source

pub unsafe fn unwrap_unchecked(self) -> T

Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.

\n
§Safety
\n

Calling this method on an Err is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
\n
1.58.0 · source

pub unsafe fn unwrap_err_unchecked(self) -> E

Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.

\n
§Safety
\n

Calling this method on an Ok is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
\n
",0,"clap::error::Result"],["
1.16.0 · source§

impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
where\n T: Sum<U>,

source§

fn sum<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.

\n
§Examples
\n

This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:

\n\n
let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
\n
","Sum>","clap::error::Result"],["
1.61.0 · source§

impl<T, E> Termination for Result<T, E>
where\n T: Termination,\n E: Debug,

source§

fn report(self) -> ExitCode

Is called to get the representation of the value as status code.\nThis status code is returned to the operating system.
","Termination","clap::error::Result"],["
source§

impl<T, E> Try for Result<T, E>

§

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value produced by ? when not short-circuiting.
§

type Residual = Result<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
source§

fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from its Output type. Read more
source§

fn branch(\n self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

🔬This is a nightly-only experimental API. (try_trait_v2)
Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
","Try","clap::error::Result"],["
1.0.0 · source§

impl<T, E> Copy for Result<T, E>
where\n T: Copy,\n E: Copy,

","Copy","clap::error::Result"],["
1.0.0 · source§

impl<T, E> Eq for Result<T, E>
where\n T: Eq,\n E: Eq,

","Eq","clap::error::Result"],["
1.0.0 · source§

impl<T, E> StructuralPartialEq for Result<T, E>

","StructuralPartialEq","clap::error::Result"]], -"clap_builder":[["
1.0.0 · source§

impl<T, E> Clone for Result<T, E>
where\n T: Clone,\n E: Clone,

source§

fn clone(&self) -> Result<T, E>

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Result<T, E>)

Performs copy-assignment from source. Read more
","Clone","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Debug for Result<T, E>
where\n T: Debug,\n E: Debug,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
","Debug","clap_builder::error::Result"],["
source§

impl From<&StreamResult> for Result<MZStatus, MZError>

source§

fn from(res: &StreamResult) -> Result<MZStatus, MZError>

Converts to this type from the input type.
","From<&StreamResult>","clap_builder::error::Result"],["
source§

impl From<StreamResult> for Result<MZStatus, MZError>

source§

fn from(res: StreamResult) -> Result<MZStatus, MZError>

Converts to this type from the input type.
","From","clap_builder::error::Result"],["
1.0.0 · source§

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
where\n V: FromIterator<A>,

source§

fn from_iter<I>(iter: I) -> Result<V, E>
where\n I: IntoIterator<Item = Result<A, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.

\n

Here is an example which increments every integer in a vector,\nchecking for overflow:

\n\n
let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
\n

Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:

\n\n
let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
\n

Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.

\n\n
let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
\n

Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.

\n
","FromIterator>","clap_builder::error::Result"],["
source§

impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","clap_builder::error::Result"],["
source§

impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(_: Yeet<E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Hash for Result<T, E>
where\n T: Hash,\n E: Hash,

source§

fn hash<__H>(&self, state: &mut __H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> IntoIterator for Result<T, E>

source§

fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
","IntoIterator","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Ord for Result<T, E>
where\n T: Ord,\n E: Ord,

source§

fn cmp(&self, other: &Result<T, E>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> PartialEq for Result<T, E>
where\n T: PartialEq,\n E: PartialEq,

source§

fn eq(&self, other: &Result<T, E>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> PartialOrd for Result<T, E>
where\n T: PartialOrd,\n E: PartialOrd,

source§

fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","clap_builder::error::Result"],["
1.16.0 · source§

impl<T, U, E> Product<Result<U, E>> for Result<T, E>
where\n T: Product<U>,

source§

fn product<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.

\n
§Examples
\n

This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:

\n\n
let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
\n
","Product>","clap_builder::error::Result"],["
source§

impl<T, E> Residual<T> for Result<Infallible, E>

§

type TryType = Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2_residual)
The “return” type of this meta-function.
","Residual","clap_builder::error::Result"],["
source§

impl<T, E> Result<&T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"clap_builder::error::Result"],["
source§

impl<T, E> Result<&mut T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&mut T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&mut T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"clap_builder::error::Result"],["
source§

impl<T, E> Result<Option<T>, E>

1.33.0 (const: unstable) · source

pub fn transpose(self) -> Option<Result<T, E>>

Transposes a Result of an Option into an Option of a Result.

\n

Ok(None) will be mapped to None.\nOk(Some(_)) and Err(_) will be mapped to Some(Ok(_)) and Some(Err(_)).

\n
§Examples
\n
#[derive(Debug, Eq, PartialEq)]\nstruct SomeErr;\n\nlet x: Result<Option<i32>, SomeErr> = Ok(Some(5));\nlet y: Option<Result<i32, SomeErr>> = Some(Ok(5));\nassert_eq!(x.transpose(), y);
\n
",0,"clap_builder::error::Result"],["
source§

impl<T, E> Result<Result<T, E>, E>

source

pub fn flatten(self) -> Result<T, E>

🔬This is a nightly-only experimental API. (result_flattening)

Converts from Result<Result<T, E>, E> to Result<T, E>

\n
§Examples
\n
#![feature(result_flattening)]\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Ok(\"hello\"));\nassert_eq!(Ok(\"hello\"), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));\nassert_eq!(Err(6), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Err(6);\nassert_eq!(Err(6), x.flatten());
\n

Flattening only removes one level of nesting at a time:

\n\n
#![feature(result_flattening)]\nlet x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok(\"hello\")));\nassert_eq!(Ok(Ok(\"hello\")), x.flatten());\nassert_eq!(Ok(\"hello\"), x.flatten().flatten());
\n
",0,"clap_builder::error::Result"],["
source§

impl<T, E> Result<T, E>

1.0.0 (const: 1.48.0) · source

pub const fn is_ok(&self) -> bool

Returns true if the result is Ok.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
\n
1.70.0 · source

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

Returns true if the result is Ok and the value inside of it matches a predicate.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
\n
1.0.0 (const: 1.48.0) · source

pub const fn is_err(&self) -> bool

Returns true if the result is Err.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
\n
1.70.0 · source

pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool

Returns true if the result is Err and the value inside of it matches a predicate.

\n
§Examples
\n
use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
\n
1.0.0 · source

pub fn ok(self) -> Option<T>

Converts from Result<T, E> to Option<T>.

\n

Converts self into an Option<T>, consuming self,\nand discarding the error, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
\n
1.0.0 · source

pub fn err(self) -> Option<E>

Converts from Result<T, E> to Option<E>.

\n

Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
\n
1.0.0 (const: 1.48.0) · source

pub const fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

\n

Produces a new Result, containing a reference\ninto the original, leaving the original in place.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
\n
1.0.0 (const: unstable) · source

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

\n
§Examples
\n
fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
\n
1.0.0 · source

pub fn map<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> U,

Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.

\n

This function can be used to compose the results of two functions.

\n
§Examples
\n

Print the numbers on each line of a string multiplied by two.

\n\n
let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
\n
1.41.0 · source

pub fn map_or<U, F>(self, default: U, f: F) -> U
where\n F: FnOnce(T) -> U,

Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).

\n

Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
\n
1.41.0 · source

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where\n D: FnOnce(E) -> U,\n F: FnOnce(T) -> U,

Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.

\n

This function can be used to unpack a successful result\nwhile handling an error.

\n
§Examples
\n
let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
\n
1.0.0 · source

pub fn map_err<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> F,

Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.

\n

This function can be used to pass through a successful result while handling\nan error.

\n
§Examples
\n
fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
\n
1.76.0 · source

pub fn inspect<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&T),

Calls a function with a reference to the contained value if Ok.

\n

Returns the original result.

\n
§Examples
\n
let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
\n
1.76.0 · source

pub fn inspect_err<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&E),

Calls a function with a reference to the contained value if Err.

\n

Returns the original result.

\n
§Examples
\n
use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
\n
1.47.0 · source

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where\n T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

\n

Coerces the Ok variant of the original Result via Deref\nand returns the new Result.

\n
§Examples
\n
let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
\n
1.47.0 · source

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where\n T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

\n

Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.

\n
§Examples
\n
let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
\n
1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
\n
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
\n
1.4.0 · source

pub fn expect(self, msg: &str) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
\n
§Recommended Message Style
\n

We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.

\n\n
ⓘ
let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
\n

Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.

\n

For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.

\n
1.0.0 · source

pub fn unwrap(self) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message provided by the\nErr’s value.

\n
§Examples
\n

Basic usage:

\n\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
\n\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
\n
1.16.0 · source

pub fn unwrap_or_default(self) -> T
where\n T: Default,

Returns the contained Ok value or a default

\n

Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.

\n
§Examples
\n

Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.

\n\n
let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
\n
1.17.0 · source

pub fn expect_err(self, msg: &str) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
\n
1.0.0 · source

pub fn unwrap_err(self) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
\n
source

pub fn into_ok(self) -> T
where\n E: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Ok value, but never panics.

\n

Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.

\n
§Examples
\n
\nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
\n
source

pub fn into_err(self) -> E
where\n T: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Err value, but never panics.

\n

Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.

\n
§Examples
\n
\nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
\n
1.0.0 · source

pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>

Returns res if the result is Ok, otherwise returns the Err value of self.

\n

Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
\n
1.0.0 · source

pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> Result<U, E>,

Calls op if the result is Ok, otherwise returns the Err value of self.

\n

This function can be used for control flow based on Result values.

\n
§Examples
\n
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
\n

Often used to chain fallible operations that may return Err.

\n\n
use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
\n
1.0.0 · source

pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

Returns res if the result is Err, otherwise returns the Ok value of self.

\n

Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
\n
1.0.0 · source

pub fn or_else<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> Result<T, F>,

Calls op if the result is Err, otherwise returns the Ok value of self.

\n

This function can be used for control flow based on result values.

\n
§Examples
\n
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
\n
1.0.0 · source

pub fn unwrap_or(self, default: T) -> T

Returns the contained Ok value or a provided default.

\n

Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
\n
1.0.0 · source

pub fn unwrap_or_else<F>(self, op: F) -> T
where\n F: FnOnce(E) -> T,

Returns the contained Ok value or computes it from a closure.

\n
§Examples
\n
fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
\n
1.58.0 · source

pub unsafe fn unwrap_unchecked(self) -> T

Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.

\n
§Safety
\n

Calling this method on an Err is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
\n
1.58.0 · source

pub unsafe fn unwrap_err_unchecked(self) -> E

Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.

\n
§Safety
\n

Calling this method on an Ok is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
\n
",0,"clap_builder::error::Result"],["
1.16.0 · source§

impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
where\n T: Sum<U>,

source§

fn sum<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.

\n
§Examples
\n

This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:

\n\n
let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
\n
","Sum>","clap_builder::error::Result"],["
1.61.0 · source§

impl<T, E> Termination for Result<T, E>
where\n T: Termination,\n E: Debug,

source§

fn report(self) -> ExitCode

Is called to get the representation of the value as status code.\nThis status code is returned to the operating system.
","Termination","clap_builder::error::Result"],["
source§

impl<T, E> Try for Result<T, E>

§

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value produced by ? when not short-circuiting.
§

type Residual = Result<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
source§

fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from its Output type. Read more
source§

fn branch(\n self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

🔬This is a nightly-only experimental API. (try_trait_v2)
Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
","Try","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Copy for Result<T, E>
where\n T: Copy,\n E: Copy,

","Copy","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Eq for Result<T, E>
where\n T: Eq,\n E: Eq,

","Eq","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> StructuralPartialEq for Result<T, E>

","StructuralPartialEq","clap_builder::error::Result"]], +"clap_builder":[["
1.0.0 · source§

impl<T, E> Clone for Result<T, E>
where\n T: Clone,\n E: Clone,

source§

fn clone(&self) -> Result<T, E>

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Result<T, E>)

Performs copy-assignment from source. Read more
","Clone","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Debug for Result<T, E>
where\n T: Debug,\n E: Debug,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
","Debug","clap_builder::error::Result"],["
source§

impl From<&StreamResult> for Result<MZStatus, MZError>

source§

fn from(res: &StreamResult) -> Result<MZStatus, MZError>

Converts to this type from the input type.
","From<&StreamResult>","clap_builder::error::Result"],["
source§

impl From<StreamResult> for Result<MZStatus, MZError>

source§

fn from(res: StreamResult) -> Result<MZStatus, MZError>

Converts to this type from the input type.
","From","clap_builder::error::Result"],["
1.0.0 · source§

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
where\n V: FromIterator<A>,

source§

fn from_iter<I>(iter: I) -> Result<V, E>
where\n I: IntoIterator<Item = Result<A, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.

\n

Here is an example which increments every integer in a vector,\nchecking for overflow:

\n\n
let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
\n

Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:

\n\n
let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
\n

Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.

\n\n
let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
\n

Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.

\n
","FromIterator>","clap_builder::error::Result"],["
source§

impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","clap_builder::error::Result"],["
source§

impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(_: Yeet<E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Hash for Result<T, E>
where\n T: Hash,\n E: Hash,

source§

fn hash<__H>(&self, state: &mut __H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> IntoIterator for Result<T, E>

source§

fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
","IntoIterator","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Ord for Result<T, E>
where\n T: Ord,\n E: Ord,

source§

fn cmp(&self, other: &Result<T, E>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> PartialEq for Result<T, E>
where\n T: PartialEq,\n E: PartialEq,

source§

fn eq(&self, other: &Result<T, E>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> PartialOrd for Result<T, E>
where\n T: PartialOrd,\n E: PartialOrd,

source§

fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","clap_builder::error::Result"],["
1.16.0 · source§

impl<T, U, E> Product<Result<U, E>> for Result<T, E>
where\n T: Product<U>,

source§

fn product<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.

\n
§Examples
\n

This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:

\n\n
let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
\n
","Product>","clap_builder::error::Result"],["
source§

impl<T, E> Residual<T> for Result<Infallible, E>

§

type TryType = Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2_residual)
The “return” type of this meta-function.
","Residual","clap_builder::error::Result"],["
source§

impl<T, E> Result<&T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"clap_builder::error::Result"],["
source§

impl<T, E> Result<&mut T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&mut T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&mut T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"clap_builder::error::Result"],["
source§

impl<T, E> Result<Option<T>, E>

1.33.0 (const: unstable) · source

pub fn transpose(self) -> Option<Result<T, E>>

Transposes a Result of an Option into an Option of a Result.

\n

Ok(None) will be mapped to None.\nOk(Some(_)) and Err(_) will be mapped to Some(Ok(_)) and Some(Err(_)).

\n
§Examples
\n
#[derive(Debug, Eq, PartialEq)]\nstruct SomeErr;\n\nlet x: Result<Option<i32>, SomeErr> = Ok(Some(5));\nlet y: Option<Result<i32, SomeErr>> = Some(Ok(5));\nassert_eq!(x.transpose(), y);
\n
",0,"clap_builder::error::Result"],["
source§

impl<T, E> Result<Result<T, E>, E>

source

pub fn flatten(self) -> Result<T, E>

🔬This is a nightly-only experimental API. (result_flattening)

Converts from Result<Result<T, E>, E> to Result<T, E>

\n
§Examples
\n
#![feature(result_flattening)]\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Ok(\"hello\"));\nassert_eq!(Ok(\"hello\"), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));\nassert_eq!(Err(6), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Err(6);\nassert_eq!(Err(6), x.flatten());
\n

Flattening only removes one level of nesting at a time:

\n\n
#![feature(result_flattening)]\nlet x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok(\"hello\")));\nassert_eq!(Ok(Ok(\"hello\")), x.flatten());\nassert_eq!(Ok(\"hello\"), x.flatten().flatten());
\n
",0,"clap_builder::error::Result"],["
source§

impl<T, E> Result<T, E>

1.0.0 (const: 1.48.0) · source

pub const fn is_ok(&self) -> bool

Returns true if the result is Ok.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
\n
1.70.0 · source

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

Returns true if the result is Ok and the value inside of it matches a predicate.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
\n
1.0.0 (const: 1.48.0) · source

pub const fn is_err(&self) -> bool

Returns true if the result is Err.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
\n
1.70.0 · source

pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool

Returns true if the result is Err and the value inside of it matches a predicate.

\n
§Examples
\n
use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
\n
1.0.0 · source

pub fn ok(self) -> Option<T>

Converts from Result<T, E> to Option<T>.

\n

Converts self into an Option<T>, consuming self,\nand discarding the error, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
\n
1.0.0 · source

pub fn err(self) -> Option<E>

Converts from Result<T, E> to Option<E>.

\n

Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
\n
1.0.0 (const: 1.48.0) · source

pub const fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

\n

Produces a new Result, containing a reference\ninto the original, leaving the original in place.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
\n
1.0.0 (const: unstable) · source

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

\n
§Examples
\n
fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
\n
1.0.0 · source

pub fn map<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> U,

Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.

\n

This function can be used to compose the results of two functions.

\n
§Examples
\n

Print the numbers on each line of a string multiplied by two.

\n\n
let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
\n
1.41.0 · source

pub fn map_or<U, F>(self, default: U, f: F) -> U
where\n F: FnOnce(T) -> U,

Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).

\n

Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
\n
1.41.0 · source

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where\n D: FnOnce(E) -> U,\n F: FnOnce(T) -> U,

Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.

\n

This function can be used to unpack a successful result\nwhile handling an error.

\n
§Examples
\n
let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
\n
1.0.0 · source

pub fn map_err<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> F,

Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.

\n

This function can be used to pass through a successful result while handling\nan error.

\n
§Examples
\n
fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
\n
1.76.0 · source

pub fn inspect<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&T),

Calls a function with a reference to the contained value if Ok.

\n

Returns the original result.

\n
§Examples
\n
let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
\n
1.76.0 · source

pub fn inspect_err<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&E),

Calls a function with a reference to the contained value if Err.

\n

Returns the original result.

\n
§Examples
\n
use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
\n
1.47.0 · source

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where\n T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

\n

Coerces the Ok variant of the original Result via Deref\nand returns the new Result.

\n
§Examples
\n
let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
\n
1.47.0 · source

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where\n T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

\n

Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.

\n
§Examples
\n
let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
\n
1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
\n
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
\n
1.4.0 · source

pub fn expect(self, msg: &str) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
\n
§Recommended Message Style
\n

We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.

\n\n
ⓘ
let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
\n

Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.

\n

For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.

\n
1.0.0 · source

pub fn unwrap(self) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message provided by the\nErr’s value.

\n
§Examples
\n

Basic usage:

\n\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
\n\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
\n
1.16.0 · source

pub fn unwrap_or_default(self) -> T
where\n T: Default,

Returns the contained Ok value or a default

\n

Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.

\n
§Examples
\n

Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.

\n\n
let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
\n
1.17.0 · source

pub fn expect_err(self, msg: &str) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
\n
1.0.0 · source

pub fn unwrap_err(self) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
\n
source

pub fn into_ok(self) -> T
where\n E: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Ok value, but never panics.

\n

Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.

\n
§Examples
\n
\nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
\n
source

pub fn into_err(self) -> E
where\n T: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Err value, but never panics.

\n

Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.

\n
§Examples
\n
\nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
\n
1.0.0 · source

pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>

Returns res if the result is Ok, otherwise returns the Err value of self.

\n

Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
\n
1.0.0 · source

pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> Result<U, E>,

Calls op if the result is Ok, otherwise returns the Err value of self.

\n

This function can be used for control flow based on Result values.

\n
§Examples
\n
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
\n

Often used to chain fallible operations that may return Err.

\n\n
use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
\n
1.0.0 · source

pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

Returns res if the result is Err, otherwise returns the Ok value of self.

\n

Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
\n
1.0.0 · source

pub fn or_else<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> Result<T, F>,

Calls op if the result is Err, otherwise returns the Ok value of self.

\n

This function can be used for control flow based on result values.

\n
§Examples
\n
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
\n
1.0.0 · source

pub fn unwrap_or(self, default: T) -> T

Returns the contained Ok value or a provided default.

\n

Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
\n
1.0.0 · source

pub fn unwrap_or_else<F>(self, op: F) -> T
where\n F: FnOnce(E) -> T,

Returns the contained Ok value or computes it from a closure.

\n
§Examples
\n
fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
\n
1.58.0 · source

pub unsafe fn unwrap_unchecked(self) -> T

Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.

\n
§Safety
\n

Calling this method on an Err is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
\n
1.58.0 · source

pub unsafe fn unwrap_err_unchecked(self) -> E

Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.

\n
§Safety
\n

Calling this method on an Ok is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
\n
",0,"clap_builder::error::Result"],["
1.16.0 · source§

impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
where\n T: Sum<U>,

source§

fn sum<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.

\n
§Examples
\n

This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:

\n\n
let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
\n
","Sum>","clap_builder::error::Result"],["
1.61.0 · source§

impl<T, E> Termination for Result<T, E>
where\n T: Termination,\n E: Debug,

source§

fn report(self) -> ExitCode

Is called to get the representation of the value as status code.\nThis status code is returned to the operating system.
","Termination","clap_builder::error::Result"],["
source§

impl<T, E> Try for Result<T, E>

§

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value produced by ? when not short-circuiting.
§

type Residual = Result<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
source§

fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from its Output type. Read more
source§

fn branch(\n self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

🔬This is a nightly-only experimental API. (try_trait_v2)
Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
","Try","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Copy for Result<T, E>
where\n T: Copy,\n E: Copy,

","Copy","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> Eq for Result<T, E>
where\n T: Eq,\n E: Eq,

","Eq","clap_builder::error::Result"],["
1.0.0 · source§

impl<T, E> StructuralPartialEq for Result<T, E>

","StructuralPartialEq","clap_builder::error::Result"]], "gimli":[["
1.0.0 · source§

impl<T, E> Clone for Result<T, E>
where\n T: Clone,\n E: Clone,

source§

fn clone(&self) -> Result<T, E>

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Result<T, E>)

Performs copy-assignment from source. Read more
","Clone","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> Debug for Result<T, E>
where\n T: Debug,\n E: Debug,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
","Debug","gimli::read::Result"],["
1.0.0 · source§

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
where\n V: FromIterator<A>,

source§

fn from_iter<I>(iter: I) -> Result<V, E>
where\n I: IntoIterator<Item = Result<A, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.

\n

Here is an example which increments every integer in a vector,\nchecking for overflow:

\n\n
let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
\n

Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:

\n\n
let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
\n

Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.

\n\n
let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
\n

Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.

\n
","FromIterator>","gimli::read::Result"],["
source§

impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","gimli::read::Result"],["
source§

impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(_: Yeet<E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> Hash for Result<T, E>
where\n T: Hash,\n E: Hash,

source§

fn hash<__H>(&self, state: &mut __H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> IntoIterator for Result<T, E>

source§

fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
","IntoIterator","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> Ord for Result<T, E>
where\n T: Ord,\n E: Ord,

source§

fn cmp(&self, other: &Result<T, E>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> PartialEq for Result<T, E>
where\n T: PartialEq,\n E: PartialEq,

source§

fn eq(&self, other: &Result<T, E>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> PartialOrd for Result<T, E>
where\n T: PartialOrd,\n E: PartialOrd,

source§

fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","gimli::read::Result"],["
1.16.0 · source§

impl<T, U, E> Product<Result<U, E>> for Result<T, E>
where\n T: Product<U>,

source§

fn product<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.

\n
§Examples
\n

This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:

\n\n
let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
\n
","Product>","gimli::read::Result"],["
source§

impl<T, E> Residual<T> for Result<Infallible, E>

§

type TryType = Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2_residual)
The “return” type of this meta-function.
","Residual","gimli::read::Result"],["
source§

impl<T, E> Result<&T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"gimli::read::Result"],["
source§

impl<T, E> Result<&mut T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&mut T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&mut T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"gimli::read::Result"],["
source§

impl<T, E> Result<Option<T>, E>

1.33.0 (const: unstable) · source

pub fn transpose(self) -> Option<Result<T, E>>

Transposes a Result of an Option into an Option of a Result.

\n

Ok(None) will be mapped to None.\nOk(Some(_)) and Err(_) will be mapped to Some(Ok(_)) and Some(Err(_)).

\n
§Examples
\n
#[derive(Debug, Eq, PartialEq)]\nstruct SomeErr;\n\nlet x: Result<Option<i32>, SomeErr> = Ok(Some(5));\nlet y: Option<Result<i32, SomeErr>> = Some(Ok(5));\nassert_eq!(x.transpose(), y);
\n
",0,"gimli::read::Result"],["
source§

impl<T, E> Result<Result<T, E>, E>

source

pub fn flatten(self) -> Result<T, E>

🔬This is a nightly-only experimental API. (result_flattening)

Converts from Result<Result<T, E>, E> to Result<T, E>

\n
§Examples
\n
#![feature(result_flattening)]\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Ok(\"hello\"));\nassert_eq!(Ok(\"hello\"), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));\nassert_eq!(Err(6), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Err(6);\nassert_eq!(Err(6), x.flatten());
\n

Flattening only removes one level of nesting at a time:

\n\n
#![feature(result_flattening)]\nlet x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok(\"hello\")));\nassert_eq!(Ok(Ok(\"hello\")), x.flatten());\nassert_eq!(Ok(\"hello\"), x.flatten().flatten());
\n
",0,"gimli::read::Result"],["
source§

impl<T, E> Result<T, E>

1.0.0 (const: 1.48.0) · source

pub const fn is_ok(&self) -> bool

Returns true if the result is Ok.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
\n
1.70.0 · source

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

Returns true if the result is Ok and the value inside of it matches a predicate.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
\n
1.0.0 (const: 1.48.0) · source

pub const fn is_err(&self) -> bool

Returns true if the result is Err.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
\n
1.70.0 · source

pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool

Returns true if the result is Err and the value inside of it matches a predicate.

\n
§Examples
\n
use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
\n
1.0.0 · source

pub fn ok(self) -> Option<T>

Converts from Result<T, E> to Option<T>.

\n

Converts self into an Option<T>, consuming self,\nand discarding the error, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
\n
1.0.0 · source

pub fn err(self) -> Option<E>

Converts from Result<T, E> to Option<E>.

\n

Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
\n
1.0.0 (const: 1.48.0) · source

pub const fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

\n

Produces a new Result, containing a reference\ninto the original, leaving the original in place.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
\n
1.0.0 (const: unstable) · source

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

\n
§Examples
\n
fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
\n
1.0.0 · source

pub fn map<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> U,

Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.

\n

This function can be used to compose the results of two functions.

\n
§Examples
\n

Print the numbers on each line of a string multiplied by two.

\n\n
let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
\n
1.41.0 · source

pub fn map_or<U, F>(self, default: U, f: F) -> U
where\n F: FnOnce(T) -> U,

Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).

\n

Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
\n
1.41.0 · source

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where\n D: FnOnce(E) -> U,\n F: FnOnce(T) -> U,

Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.

\n

This function can be used to unpack a successful result\nwhile handling an error.

\n
§Examples
\n
let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
\n
1.0.0 · source

pub fn map_err<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> F,

Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.

\n

This function can be used to pass through a successful result while handling\nan error.

\n
§Examples
\n
fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
\n
1.76.0 · source

pub fn inspect<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&T),

Calls a function with a reference to the contained value if Ok.

\n

Returns the original result.

\n
§Examples
\n
let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
\n
1.76.0 · source

pub fn inspect_err<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&E),

Calls a function with a reference to the contained value if Err.

\n

Returns the original result.

\n
§Examples
\n
use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
\n
1.47.0 · source

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where\n T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

\n

Coerces the Ok variant of the original Result via Deref\nand returns the new Result.

\n
§Examples
\n
let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
\n
1.47.0 · source

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where\n T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

\n

Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.

\n
§Examples
\n
let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
\n
1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
\n
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
\n
1.4.0 · source

pub fn expect(self, msg: &str) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
\n
§Recommended Message Style
\n

We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.

\n\n
ⓘ
let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
\n

Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.

\n

For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.

\n
1.0.0 · source

pub fn unwrap(self) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message provided by the\nErr’s value.

\n
§Examples
\n

Basic usage:

\n\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
\n\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
\n
1.16.0 · source

pub fn unwrap_or_default(self) -> T
where\n T: Default,

Returns the contained Ok value or a default

\n

Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.

\n
§Examples
\n

Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.

\n\n
let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
\n
1.17.0 · source

pub fn expect_err(self, msg: &str) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
\n
1.0.0 · source

pub fn unwrap_err(self) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
\n
source

pub fn into_ok(self) -> T
where\n E: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Ok value, but never panics.

\n

Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.

\n
§Examples
\n
\nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
\n
source

pub fn into_err(self) -> E
where\n T: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Err value, but never panics.

\n

Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.

\n
§Examples
\n
\nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
\n
1.0.0 · source

pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>

Returns res if the result is Ok, otherwise returns the Err value of self.

\n

Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
\n
1.0.0 · source

pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> Result<U, E>,

Calls op if the result is Ok, otherwise returns the Err value of self.

\n

This function can be used for control flow based on Result values.

\n
§Examples
\n
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
\n

Often used to chain fallible operations that may return Err.

\n\n
use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
\n
1.0.0 · source

pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

Returns res if the result is Err, otherwise returns the Ok value of self.

\n

Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
\n
1.0.0 · source

pub fn or_else<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> Result<T, F>,

Calls op if the result is Err, otherwise returns the Ok value of self.

\n

This function can be used for control flow based on result values.

\n
§Examples
\n
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
\n
1.0.0 · source

pub fn unwrap_or(self, default: T) -> T

Returns the contained Ok value or a provided default.

\n

Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
\n
1.0.0 · source

pub fn unwrap_or_else<F>(self, op: F) -> T
where\n F: FnOnce(E) -> T,

Returns the contained Ok value or computes it from a closure.

\n
§Examples
\n
fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
\n
1.58.0 · source

pub unsafe fn unwrap_unchecked(self) -> T

Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.

\n
§Safety
\n

Calling this method on an Err is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
\n
1.58.0 · source

pub unsafe fn unwrap_err_unchecked(self) -> E

Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.

\n
§Safety
\n

Calling this method on an Ok is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
\n
",0,"gimli::read::Result"],["
1.16.0 · source§

impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
where\n T: Sum<U>,

source§

fn sum<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.

\n
§Examples
\n

This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:

\n\n
let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
\n
","Sum>","gimli::read::Result"],["
source§

impl<T, E> Try for Result<T, E>

§

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value produced by ? when not short-circuiting.
§

type Residual = Result<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
source§

fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from its Output type. Read more
source§

fn branch(\n self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

🔬This is a nightly-only experimental API. (try_trait_v2)
Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
","Try","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> Copy for Result<T, E>
where\n T: Copy,\n E: Copy,

","Copy","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> Eq for Result<T, E>
where\n T: Eq,\n E: Eq,

","Eq","gimli::read::Result"],["
1.0.0 · source§

impl<T, E> StructuralPartialEq for Result<T, E>

","StructuralPartialEq","gimli::read::Result"]], "lzma_rs":[["
1.0.0 · source§

impl<T, E> Clone for Result<T, E>
where\n T: Clone,\n E: Clone,

source§

fn clone(&self) -> Result<T, E>

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Result<T, E>)

Performs copy-assignment from source. Read more
","Clone","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> Debug for Result<T, E>
where\n T: Debug,\n E: Debug,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
","Debug","lzma_rs::error::Result"],["
1.0.0 · source§

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
where\n V: FromIterator<A>,

source§

fn from_iter<I>(iter: I) -> Result<V, E>
where\n I: IntoIterator<Item = Result<A, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.

\n

Here is an example which increments every integer in a vector,\nchecking for overflow:

\n\n
let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
\n

Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:

\n\n
let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
\n

Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.

\n\n
let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
\n

Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.

\n
","FromIterator>","lzma_rs::error::Result"],["
source§

impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","lzma_rs::error::Result"],["
source§

impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(_: Yeet<E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> Hash for Result<T, E>
where\n T: Hash,\n E: Hash,

source§

fn hash<__H>(&self, state: &mut __H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> IntoIterator for Result<T, E>

source§

fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
","IntoIterator","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> Ord for Result<T, E>
where\n T: Ord,\n E: Ord,

source§

fn cmp(&self, other: &Result<T, E>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> PartialEq for Result<T, E>
where\n T: PartialEq,\n E: PartialEq,

source§

fn eq(&self, other: &Result<T, E>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> PartialOrd for Result<T, E>
where\n T: PartialOrd,\n E: PartialOrd,

source§

fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","lzma_rs::error::Result"],["
1.16.0 · source§

impl<T, U, E> Product<Result<U, E>> for Result<T, E>
where\n T: Product<U>,

source§

fn product<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.

\n
§Examples
\n

This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:

\n\n
let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
\n
","Product>","lzma_rs::error::Result"],["
source§

impl<T, E> Residual<T> for Result<Infallible, E>

§

type TryType = Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2_residual)
The “return” type of this meta-function.
","Residual","lzma_rs::error::Result"],["
source§

impl<T, E> Result<&T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let val = 12;\nlet x: Result<&i32, i32> = Ok(&val);\nassert_eq!(x, Ok(&12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"lzma_rs::error::Result"],["
source§

impl<T, E> Result<&mut T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>
where\n T: Copy,

Maps a Result<&mut T, E> to a Result<T, E> by copying the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet copied = x.copied();\nassert_eq!(copied, Ok(12));
\n
1.59.0 · source

pub fn cloned(self) -> Result<T, E>
where\n T: Clone,

Maps a Result<&mut T, E> to a Result<T, E> by cloning the contents of the\nOk part.

\n
§Examples
\n
let mut val = 12;\nlet x: Result<&mut i32, i32> = Ok(&mut val);\nassert_eq!(x, Ok(&mut 12));\nlet cloned = x.cloned();\nassert_eq!(cloned, Ok(12));
\n
",0,"lzma_rs::error::Result"],["
source§

impl<T, E> Result<Option<T>, E>

1.33.0 (const: unstable) · source

pub fn transpose(self) -> Option<Result<T, E>>

Transposes a Result of an Option into an Option of a Result.

\n

Ok(None) will be mapped to None.\nOk(Some(_)) and Err(_) will be mapped to Some(Ok(_)) and Some(Err(_)).

\n
§Examples
\n
#[derive(Debug, Eq, PartialEq)]\nstruct SomeErr;\n\nlet x: Result<Option<i32>, SomeErr> = Ok(Some(5));\nlet y: Option<Result<i32, SomeErr>> = Some(Ok(5));\nassert_eq!(x.transpose(), y);
\n
",0,"lzma_rs::error::Result"],["
source§

impl<T, E> Result<Result<T, E>, E>

source

pub fn flatten(self) -> Result<T, E>

🔬This is a nightly-only experimental API. (result_flattening)

Converts from Result<Result<T, E>, E> to Result<T, E>

\n
§Examples
\n
#![feature(result_flattening)]\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Ok(\"hello\"));\nassert_eq!(Ok(\"hello\"), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));\nassert_eq!(Err(6), x.flatten());\n\nlet x: Result<Result<&'static str, u32>, u32> = Err(6);\nassert_eq!(Err(6), x.flatten());
\n

Flattening only removes one level of nesting at a time:

\n\n
#![feature(result_flattening)]\nlet x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok(\"hello\")));\nassert_eq!(Ok(Ok(\"hello\")), x.flatten());\nassert_eq!(Ok(\"hello\"), x.flatten().flatten());
\n
",0,"lzma_rs::error::Result"],["
source§

impl<T, E> Result<T, E>

1.0.0 (const: 1.48.0) · source

pub const fn is_ok(&self) -> bool

Returns true if the result is Ok.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
\n
1.70.0 · source

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

Returns true if the result is Ok and the value inside of it matches a predicate.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
\n
1.0.0 (const: 1.48.0) · source

pub const fn is_err(&self) -> bool

Returns true if the result is Err.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
\n
1.70.0 · source

pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool

Returns true if the result is Err and the value inside of it matches a predicate.

\n
§Examples
\n
use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
\n
1.0.0 · source

pub fn ok(self) -> Option<T>

Converts from Result<T, E> to Option<T>.

\n

Converts self into an Option<T>, consuming self,\nand discarding the error, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
\n
1.0.0 · source

pub fn err(self) -> Option<E>

Converts from Result<T, E> to Option<E>.

\n

Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
\n
1.0.0 (const: 1.48.0) · source

pub const fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

\n

Produces a new Result, containing a reference\ninto the original, leaving the original in place.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
\n
1.0.0 (const: unstable) · source

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

\n
§Examples
\n
fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
\n
1.0.0 · source

pub fn map<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> U,

Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.

\n

This function can be used to compose the results of two functions.

\n
§Examples
\n

Print the numbers on each line of a string multiplied by two.

\n\n
let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
\n
1.41.0 · source

pub fn map_or<U, F>(self, default: U, f: F) -> U
where\n F: FnOnce(T) -> U,

Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).

\n

Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
\n
1.41.0 · source

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where\n D: FnOnce(E) -> U,\n F: FnOnce(T) -> U,

Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.

\n

This function can be used to unpack a successful result\nwhile handling an error.

\n
§Examples
\n
let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
\n
1.0.0 · source

pub fn map_err<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> F,

Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.

\n

This function can be used to pass through a successful result while handling\nan error.

\n
§Examples
\n
fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
\n
1.76.0 · source

pub fn inspect<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&T),

Calls a function with a reference to the contained value if Ok.

\n

Returns the original result.

\n
§Examples
\n
let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
\n
1.76.0 · source

pub fn inspect_err<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&E),

Calls a function with a reference to the contained value if Err.

\n

Returns the original result.

\n
§Examples
\n
use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
\n
1.47.0 · source

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where\n T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

\n

Coerces the Ok variant of the original Result via Deref\nand returns the new Result.

\n
§Examples
\n
let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
\n
1.47.0 · source

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where\n T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

\n

Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.

\n
§Examples
\n
let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
\n
1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
\n
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
\n
1.4.0 · source

pub fn expect(self, msg: &str) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
\n
§Recommended Message Style
\n

We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.

\n\n
ⓘ
let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
\n

Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.

\n

For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.

\n
1.0.0 · source

pub fn unwrap(self) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message provided by the\nErr’s value.

\n
§Examples
\n

Basic usage:

\n\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
\n\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
\n
1.16.0 · source

pub fn unwrap_or_default(self) -> T
where\n T: Default,

Returns the contained Ok value or a default

\n

Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.

\n
§Examples
\n

Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.

\n\n
let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
\n
1.17.0 · source

pub fn expect_err(self, msg: &str) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
\n
1.0.0 · source

pub fn unwrap_err(self) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
\n
source

pub fn into_ok(self) -> T
where\n E: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Ok value, but never panics.

\n

Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.

\n
§Examples
\n
\nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
\n
source

pub fn into_err(self) -> E
where\n T: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Err value, but never panics.

\n

Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.

\n
§Examples
\n
\nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
\n
1.0.0 · source

pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>

Returns res if the result is Ok, otherwise returns the Err value of self.

\n

Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
\n
1.0.0 · source

pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> Result<U, E>,

Calls op if the result is Ok, otherwise returns the Err value of self.

\n

This function can be used for control flow based on Result values.

\n
§Examples
\n
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
\n

Often used to chain fallible operations that may return Err.

\n\n
use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
\n
1.0.0 · source

pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

Returns res if the result is Err, otherwise returns the Ok value of self.

\n

Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
\n
1.0.0 · source

pub fn or_else<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> Result<T, F>,

Calls op if the result is Err, otherwise returns the Ok value of self.

\n

This function can be used for control flow based on result values.

\n
§Examples
\n
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
\n
1.0.0 · source

pub fn unwrap_or(self, default: T) -> T

Returns the contained Ok value or a provided default.

\n

Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
\n
1.0.0 · source

pub fn unwrap_or_else<F>(self, op: F) -> T
where\n F: FnOnce(E) -> T,

Returns the contained Ok value or computes it from a closure.

\n
§Examples
\n
fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
\n
1.58.0 · source

pub unsafe fn unwrap_unchecked(self) -> T

Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.

\n
§Safety
\n

Calling this method on an Err is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
\n
1.58.0 · source

pub unsafe fn unwrap_err_unchecked(self) -> E

Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.

\n
§Safety
\n

Calling this method on an Ok is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
\n
",0,"lzma_rs::error::Result"],["
1.16.0 · source§

impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
where\n T: Sum<U>,

source§

fn sum<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.

\n
§Examples
\n

This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:

\n\n
let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
\n
","Sum>","lzma_rs::error::Result"],["
1.61.0 · source§

impl<T, E> Termination for Result<T, E>
where\n T: Termination,\n E: Debug,

source§

fn report(self) -> ExitCode

Is called to get the representation of the value as status code.\nThis status code is returned to the operating system.
","Termination","lzma_rs::error::Result"],["
source§

impl<T, E> Try for Result<T, E>

§

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value produced by ? when not short-circuiting.
§

type Residual = Result<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
source§

fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from its Output type. Read more
source§

fn branch(\n self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

🔬This is a nightly-only experimental API. (try_trait_v2)
Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
","Try","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> Copy for Result<T, E>
where\n T: Copy,\n E: Copy,

","Copy","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> Eq for Result<T, E>
where\n T: Eq,\n E: Eq,

","Eq","lzma_rs::error::Result"],["
1.0.0 · source§

impl<T, E> StructuralPartialEq for Result<T, E>

","StructuralPartialEq","lzma_rs::error::Result"]], "miniz_oxide":[["
1.0.0 · source§

impl<T, E> Clone for Result<T, E>
where\n T: Clone,\n E: Clone,

source§

fn clone(&self) -> Result<T, E>

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, source: &Result<T, E>)

Performs copy-assignment from source. Read more
","Clone","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> Debug for Result<T, E>
where\n T: Debug,\n E: Debug,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
","Debug","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E>
where\n V: FromIterator<A>,

source§

fn from_iter<I>(iter: I) -> Result<V, E>
where\n I: IntoIterator<Item = Result<A, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err occur, a\ncontainer with the values of each Result is returned.

\n

Here is an example which increments every integer in a vector,\nchecking for overflow:

\n\n
let v = vec![1, 2];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_add(1).ok_or(\"Overflow!\")\n).collect();\nassert_eq!(res, Ok(vec![2, 3]));
\n

Here is another example that tries to subtract one from another list\nof integers, this time checking for underflow:

\n\n
let v = vec![1, 2, 0];\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    x.checked_sub(1).ok_or(\"Underflow!\")\n).collect();\nassert_eq!(res, Err(\"Underflow!\"));
\n

Here is a variation on the previous example, showing that no\nfurther elements are taken from iter after the first Err.

\n\n
let v = vec![3, 2, 1, 10];\nlet mut shared = 0;\nlet res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {\n    shared += x;\n    x.checked_sub(2).ok_or(\"Underflow!\")\n}).collect();\nassert_eq!(res, Err(\"Underflow!\"));\nassert_eq!(shared, 6);
\n

Since the third element caused an underflow, no further elements were taken,\nso the final value of shared is 6 (= 3 + 2 + 1), not 16.

\n
","FromIterator>","miniz_oxide::MZResult"],["
source§

impl<T, E, F> FromResidual<Result<Infallible, E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(residual: Result<Infallible, E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","miniz_oxide::MZResult"],["
source§

impl<T, E, F> FromResidual<Yeet<E>> for Result<T, F>
where\n F: From<E>,

source§

fn from_residual(_: Yeet<E>) -> Result<T, F>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from a compatible Residual type. Read more
","FromResidual>","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> Hash for Result<T, E>
where\n T: Hash,\n E: Hash,

source§

fn hash<__H>(&self, state: &mut __H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> IntoIterator for Result<T, E>

source§

fn into_iter(self) -> IntoIter<T>

Returns a consuming iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(5);\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, [5]);\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nlet v: Vec<u32> = x.into_iter().collect();\nassert_eq!(v, []);
\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
","IntoIterator","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> Ord for Result<T, E>
where\n T: Ord,\n E: Ord,

source§

fn cmp(&self, other: &Result<T, E>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> PartialEq for Result<T, E>
where\n T: PartialEq,\n E: PartialEq,

source§

fn eq(&self, other: &Result<T, E>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> PartialOrd for Result<T, E>
where\n T: PartialOrd,\n E: PartialOrd,

source§

fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","miniz_oxide::MZResult"],["
1.16.0 · source§

impl<T, U, E> Product<Result<U, E>> for Result<T, E>
where\n T: Product<U>,

source§

fn product<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the product of all elements is returned.

\n
§Examples
\n

This multiplies each number in a vector of strings,\nif a string could not be parsed the operation returns Err:

\n\n
let nums = vec![\"5\", \"10\", \"1\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert_eq!(total, Ok(100));\nlet nums = vec![\"5\", \"10\", \"one\", \"2\"];\nlet total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();\nassert!(total.is_err());
\n
","Product>","miniz_oxide::MZResult"],["
source§

impl<T, E> Result<T, E>

1.0.0 (const: 1.48.0) · source

pub const fn is_ok(&self) -> bool

Returns true if the result is Ok.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_ok(), true);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_ok(), false);
\n
1.70.0 · source

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

Returns true if the result is Ok and the value inside of it matches a predicate.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.is_ok_and(|x| x > 1), true);\n\nlet x: Result<u32, &str> = Ok(0);\nassert_eq!(x.is_ok_and(|x| x > 1), false);\n\nlet x: Result<u32, &str> = Err(\"hey\");\nassert_eq!(x.is_ok_and(|x| x > 1), false);
\n
1.0.0 (const: 1.48.0) · source

pub const fn is_err(&self) -> bool

Returns true if the result is Err.

\n
§Examples
\n
let x: Result<i32, &str> = Ok(-3);\nassert_eq!(x.is_err(), false);\n\nlet x: Result<i32, &str> = Err(\"Some error message\");\nassert_eq!(x.is_err(), true);
\n
1.70.0 · source

pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool

Returns true if the result is Err and the value inside of it matches a predicate.

\n
§Examples
\n
use std::io::{Error, ErrorKind};\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);\n\nlet x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, \"!\"));\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);\n\nlet x: Result<u32, Error> = Ok(123);\nassert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
\n
1.0.0 · source

pub fn ok(self) -> Option<T>

Converts from Result<T, E> to Option<T>.

\n

Converts self into an Option<T>, consuming self,\nand discarding the error, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.ok(), Some(2));\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.ok(), None);
\n
1.0.0 · source

pub fn err(self) -> Option<E>

Converts from Result<T, E> to Option<E>.

\n

Converts self into an Option<E>, consuming self,\nand discarding the success value, if any.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.err(), None);\n\nlet x: Result<u32, &str> = Err(\"Nothing here\");\nassert_eq!(x.err(), Some(\"Nothing here\"));
\n
1.0.0 (const: 1.48.0) · source

pub const fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

\n

Produces a new Result, containing a reference\ninto the original, leaving the original in place.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.as_ref(), Ok(&2));\n\nlet x: Result<u32, &str> = Err(\"Error\");\nassert_eq!(x.as_ref(), Err(&\"Error\"));
\n
1.0.0 (const: unstable) · source

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

\n
§Examples
\n
fn mutate(r: &mut Result<i32, i32>) {\n    match r.as_mut() {\n        Ok(v) => *v = 42,\n        Err(e) => *e = 0,\n    }\n}\n\nlet mut x: Result<i32, i32> = Ok(2);\nmutate(&mut x);\nassert_eq!(x.unwrap(), 42);\n\nlet mut x: Result<i32, i32> = Err(13);\nmutate(&mut x);\nassert_eq!(x.unwrap_err(), 0);
\n
1.0.0 · source

pub fn map<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> U,

Maps a Result<T, E> to Result<U, E> by applying a function to a\ncontained Ok value, leaving an Err value untouched.

\n

This function can be used to compose the results of two functions.

\n
§Examples
\n

Print the numbers on each line of a string multiplied by two.

\n\n
let line = \"1\\n2\\n3\\n4\\n\";\n\nfor num in line.lines() {\n    match num.parse::<i32>().map(|i| i * 2) {\n        Ok(n) => println!(\"{n}\"),\n        Err(..) => {}\n    }\n}
\n
1.41.0 · source

pub fn map_or<U, F>(self, default: U, f: F) -> U
where\n F: FnOnce(T) -> U,

Returns the provided default (if Err), or\napplies a function to the contained value (if Ok).

\n

Arguments passed to map_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use map_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let x: Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or(42, |v| v.len()), 3);\n\nlet x: Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or(42, |v| v.len()), 42);
\n
1.41.0 · source

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where\n D: FnOnce(E) -> U,\n F: FnOnce(T) -> U,

Maps a Result<T, E> to U by applying fallback function default to\na contained Err value, or function f to a contained Ok value.

\n

This function can be used to unpack a successful result\nwhile handling an error.

\n
§Examples
\n
let k = 21;\n\nlet x : Result<_, &str> = Ok(\"foo\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n\nlet x : Result<&str, _> = Err(\"bar\");\nassert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);
\n
1.0.0 · source

pub fn map_err<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> F,

Maps a Result<T, E> to Result<T, F> by applying a function to a\ncontained Err value, leaving an Ok value untouched.

\n

This function can be used to pass through a successful result while handling\nan error.

\n
§Examples
\n
fn stringify(x: u32) -> String { format!(\"error code: {x}\") }\n\nlet x: Result<u32, u32> = Ok(2);\nassert_eq!(x.map_err(stringify), Ok(2));\n\nlet x: Result<u32, u32> = Err(13);\nassert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));
\n
1.76.0 · source

pub fn inspect<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&T),

Calls a function with a reference to the contained value if Ok.

\n

Returns the original result.

\n
§Examples
\n
let x: u8 = \"4\"\n    .parse::<u8>()\n    .inspect(|x| println!(\"original: {x}\"))\n    .map(|x| x.pow(3))\n    .expect(\"failed to parse number\");
\n
1.76.0 · source

pub fn inspect_err<F>(self, f: F) -> Result<T, E>
where\n F: FnOnce(&E),

Calls a function with a reference to the contained value if Err.

\n

Returns the original result.

\n
§Examples
\n
use std::{fs, io};\n\nfn read() -> io::Result<String> {\n    fs::read_to_string(\"address.txt\")\n        .inspect_err(|e| eprintln!(\"failed to read file: {e}\"))\n}
\n
1.47.0 · source

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>
where\n T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

\n

Coerces the Ok variant of the original Result via Deref\nand returns the new Result.

\n
§Examples
\n
let x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&str, &u32> = Ok(\"hello\");\nassert_eq!(x.as_deref(), y);\n\nlet x: Result<String, u32> = Err(42);\nlet y: Result<&str, &u32> = Err(&42);\nassert_eq!(x.as_deref(), y);
\n
1.47.0 · source

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>
where\n T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

\n

Coerces the Ok variant of the original Result via DerefMut\nand returns the new Result.

\n
§Examples
\n
let mut s = \"HELLO\".to_string();\nlet mut x: Result<String, u32> = Ok(\"hello\".to_string());\nlet y: Result<&mut str, &mut u32> = Ok(&mut s);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);\n\nlet mut i = 42;\nlet mut x: Result<String, u32> = Err(42);\nlet y: Result<&mut str, &mut u32> = Err(&mut i);\nassert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
\n
1.0.0 · source

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(7);\nassert_eq!(x.iter().next(), Some(&7));\n\nlet x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter().next(), None);
\n
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

\n

The iterator yields one value if the result is Result::Ok, otherwise none.

\n
§Examples
\n
let mut x: Result<u32, &str> = Ok(7);\nmatch x.iter_mut().next() {\n    Some(v) => *v = 40,\n    None => {},\n}\nassert_eq!(x, Ok(40));\n\nlet mut x: Result<u32, &str> = Err(\"nothing!\");\nassert_eq!(x.iter_mut().next(), None);
\n
1.4.0 · source

pub fn expect(self, msg: &str) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message including the\npassed message, and the content of the Err.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`
\n
§Recommended Message Style
\n

We recommend that expect messages are used to describe the reason you\nexpect the Result should be Ok.

\n\n
ⓘ
let path = std::env::var(\"IMPORTANT_PATH\")\n    .expect(\"env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`\");
\n

Hint: If you’re having trouble remembering how to phrase expect\nerror messages remember to focus on the word “should” as in “env\nvariable should be set by blah” or “the given binary should be available\nand executable by the current user”.

\n

For more detail on expect message styles and the reasoning behind our recommendation please\nrefer to the section on “Common Message\nStyles” in the\nstd::error module docs.

\n
1.0.0 · source

pub fn unwrap(self) -> T
where\n E: Debug,

Returns the contained Ok value, consuming the self value.

\n

Because this function may panic, its use is generally discouraged.\nInstead, prefer to use pattern matching and handle the Err\ncase explicitly, or call unwrap_or, unwrap_or_else, or\nunwrap_or_default.

\n
§Panics
\n

Panics if the value is an Err, with a panic message provided by the\nErr’s value.

\n
§Examples
\n

Basic usage:

\n\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(x.unwrap(), 2);
\n\n
ⓘ
let x: Result<u32, &str> = Err(\"emergency failure\");\nx.unwrap(); // panics with `emergency failure`
\n
1.16.0 · source

pub fn unwrap_or_default(self) -> T
where\n T: Default,

Returns the contained Ok value or a default

\n

Consumes the self argument then, if Ok, returns the contained\nvalue, otherwise if Err, returns the default value for that\ntype.

\n
§Examples
\n

Converts a string to an integer, turning poorly-formed strings\ninto 0 (the default value for integers). parse converts\na string to any other type that implements FromStr, returning an\nErr on error.

\n\n
let good_year_from_input = \"1909\";\nlet bad_year_from_input = \"190blarg\";\nlet good_year = good_year_from_input.parse().unwrap_or_default();\nlet bad_year = bad_year_from_input.parse().unwrap_or_default();\n\nassert_eq!(1909, good_year);\nassert_eq!(0, bad_year);
\n
1.17.0 · source

pub fn expect_err(self, msg: &str) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a panic message including the\npassed message, and the content of the Ok.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(10);\nx.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`
\n
1.0.0 · source

pub fn unwrap_err(self) -> E
where\n T: Debug,

Returns the contained Err value, consuming the self value.

\n
§Panics
\n

Panics if the value is an Ok, with a custom panic message provided\nby the Ok’s value.

\n
§Examples
\n
ⓘ
let x: Result<u32, &str> = Ok(2);\nx.unwrap_err(); // panics with `2`
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(x.unwrap_err(), \"emergency failure\");
\n
source

pub fn into_ok(self) -> T
where\n E: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Ok value, but never panics.

\n

Unlike unwrap, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap as a maintainability safeguard that will fail\nto compile if the error type of the Result is later changed\nto an error that can actually occur.

\n
§Examples
\n
\nfn only_good_news() -> Result<String, !> {\n    Ok(\"this is fine\".into())\n}\n\nlet s: String = only_good_news().into_ok();\nprintln!(\"{s}\");
\n
source

pub fn into_err(self) -> E
where\n T: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible)

Returns the contained Err value, but never panics.

\n

Unlike unwrap_err, this method is known to never panic on the\nresult types it is implemented for. Therefore, it can be used\ninstead of unwrap_err as a maintainability safeguard that will fail\nto compile if the ok type of the Result is later changed\nto a type that can actually occur.

\n
§Examples
\n
\nfn only_bad_news() -> Result<!, String> {\n    Err(\"Oops, it failed\".into())\n}\n\nlet error: String = only_bad_news().into_err();\nprintln!(\"{error}\");
\n
1.0.0 · source

pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>

Returns res if the result is Ok, otherwise returns the Err value of self.

\n

Arguments passed to and are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use and_then, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<&str, &str> = Ok(\"foo\");\nassert_eq!(x.and(y), Err(\"early error\"));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<&str, &str> = Err(\"late error\");\nassert_eq!(x.and(y), Err(\"not a 2\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<&str, &str> = Ok(\"different result type\");\nassert_eq!(x.and(y), Ok(\"different result type\"));
\n
1.0.0 · source

pub fn and_then<U, F>(self, op: F) -> Result<U, E>
where\n F: FnOnce(T) -> Result<U, E>,

Calls op if the result is Ok, otherwise returns the Err value of self.

\n

This function can be used for control flow based on Result values.

\n
§Examples
\n
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {\n    x.checked_mul(x).map(|sq| sq.to_string()).ok_or(\"overflowed\")\n}\n\nassert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));\nassert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err(\"overflowed\"));\nassert_eq!(Err(\"not a number\").and_then(sq_then_to_string), Err(\"not a number\"));
\n

Often used to chain fallible operations that may return Err.

\n\n
use std::{io::ErrorKind, path::Path};\n\n// Note: on Windows \"/\" maps to \"C:\\\"\nlet root_modified_time = Path::new(\"/\").metadata().and_then(|md| md.modified());\nassert!(root_modified_time.is_ok());\n\nlet should_fail = Path::new(\"/bad/path\").metadata().and_then(|md| md.modified());\nassert!(should_fail.is_err());\nassert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
\n
1.0.0 · source

pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

Returns res if the result is Err, otherwise returns the Ok value of self.

\n

Arguments passed to or are eagerly evaluated; if you are passing the\nresult of a function call, it is recommended to use or_else, which is\nlazily evaluated.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"early error\");\nlet y: Result<u32, &str> = Ok(2);\nassert_eq!(x.or(y), Ok(2));\n\nlet x: Result<u32, &str> = Err(\"not a 2\");\nlet y: Result<u32, &str> = Err(\"late error\");\nassert_eq!(x.or(y), Err(\"late error\"));\n\nlet x: Result<u32, &str> = Ok(2);\nlet y: Result<u32, &str> = Ok(100);\nassert_eq!(x.or(y), Ok(2));
\n
1.0.0 · source

pub fn or_else<F, O>(self, op: O) -> Result<T, F>
where\n O: FnOnce(E) -> Result<T, F>,

Calls op if the result is Err, otherwise returns the Ok value of self.

\n

This function can be used for control flow based on result values.

\n
§Examples
\n
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\nfn err(x: u32) -> Result<u32, u32> { Err(x) }\n\nassert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\nassert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\nassert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\nassert_eq!(Err(3).or_else(err).or_else(err), Err(3));
\n
1.0.0 · source

pub fn unwrap_or(self, default: T) -> T

Returns the contained Ok value or a provided default.

\n

Arguments passed to unwrap_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use unwrap_or_else,\nwhich is lazily evaluated.

\n
§Examples
\n
let default = 2;\nlet x: Result<u32, &str> = Ok(9);\nassert_eq!(x.unwrap_or(default), 9);\n\nlet x: Result<u32, &str> = Err(\"error\");\nassert_eq!(x.unwrap_or(default), default);
\n
1.0.0 · source

pub fn unwrap_or_else<F>(self, op: F) -> T
where\n F: FnOnce(E) -> T,

Returns the contained Ok value or computes it from a closure.

\n
§Examples
\n
fn count(x: &str) -> usize { x.len() }\n\nassert_eq!(Ok(2).unwrap_or_else(count), 2);\nassert_eq!(Err(\"foo\").unwrap_or_else(count), 3);
\n
1.58.0 · source

pub unsafe fn unwrap_unchecked(self) -> T

Returns the contained Ok value, consuming the self value,\nwithout checking that the value is not an Err.

\n
§Safety
\n

Calling this method on an Err is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nassert_eq!(unsafe { x.unwrap_unchecked() }, 2);
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nunsafe { x.unwrap_unchecked(); } // Undefined behavior!
\n
1.58.0 · source

pub unsafe fn unwrap_err_unchecked(self) -> E

Returns the contained Err value, consuming the self value,\nwithout checking that the value is not an Ok.

\n
§Safety
\n

Calling this method on an Ok is undefined behavior.

\n
§Examples
\n
let x: Result<u32, &str> = Ok(2);\nunsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
\n\n
let x: Result<u32, &str> = Err(\"emergency failure\");\nassert_eq!(unsafe { x.unwrap_err_unchecked() }, \"emergency failure\");
\n
",0,"miniz_oxide::MZResult"],["
1.16.0 · source§

impl<T, U, E> Sum<Result<U, E>> for Result<T, E>
where\n T: Sum<U>,

source§

fn sum<I>(iter: I) -> Result<T, E>
where\n I: Iterator<Item = Result<U, E>>,

Takes each element in the Iterator: if it is an Err, no further\nelements are taken, and the Err is returned. Should no Err\noccur, the sum of all elements is returned.

\n
§Examples
\n

This sums up every integer in a vector, rejecting the sum if a negative\nelement is encountered:

\n\n
let f = |&x: &i32| if x < 0 { Err(\"Negative element found\") } else { Ok(x) };\nlet v = vec![1, 2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Ok(3));\nlet v = vec![1, -2];\nlet res: Result<i32, _> = v.iter().map(f).sum();\nassert_eq!(res, Err(\"Negative element found\"));
\n
","Sum>","miniz_oxide::MZResult"],["
source§

impl<T, E> Try for Result<T, E>

§

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value produced by ? when not short-circuiting.
§

type Residual = Result<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
The type of the value passed to FromResidual::from_residual\nas part of ? when short-circuiting. Read more
source§

fn from_output(output: <Result<T, E> as Try>::Output) -> Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2)
Constructs the type from its Output type. Read more
source§

fn branch(\n self\n) -> ControlFlow<<Result<T, E> as Try>::Residual, <Result<T, E> as Try>::Output>

🔬This is a nightly-only experimental API. (try_trait_v2)
Used in ? to decide whether the operator should produce a value\n(because this returned ControlFlow::Continue)\nor propagate a value back to the caller\n(because this returned ControlFlow::Break). Read more
","Try","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> Copy for Result<T, E>
where\n T: Copy,\n E: Copy,

","Copy","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> Eq for Result<T, E>
where\n T: Eq,\n E: Eq,

","Eq","miniz_oxide::MZResult"],["
1.0.0 · source§

impl<T, E> StructuralPartialEq for Result<T, E>

","StructuralPartialEq","miniz_oxide::MZResult"]],