### XChaCha20Poly1305 Encryption and Decryption Example

Source: https://docs.rs/chacha20poly1305/latest/src/chacha20poly1305/lib.rs.html

Demonstrates how to generate a key and nonce, encrypt a message, and then decrypt it using XChaCha20Poly1305. Requires the 'getrandom' and 'std' features.

```rust
#![cfg_attr(all(feature = "getrandom", feature = "std"), doc = "```")]
#![cfg_attr(not(all(feature = "getrandom", feature = "std")), doc = "```ignore")]
# fn main() -> Result<(), Box<dyn std::error::Error>> {
use chacha20poly1305::{
    aead::{Aead, AeadCore, KeyInit, OsRng},
    XChaCha20Poly1305, XNonce
};

let key = XChaCha20Poly1305::generate_key(&mut OsRng);
let cipher = XChaCha20Poly1305::new(&key);
let nonce = XChaCha20Poly1305::generate_nonce(&mut OsRng); // 192-bits; unique per message
let ciphertext = cipher.encrypt(&nonce, b"plaintext message".as_ref())?;
let plaintext = cipher.decrypt(&nonce, ciphertext.as_ref())?;
assert_eq!(&plaintext, b"plaintext message");
# Ok(())
# }
```
```

--------------------------------

### Get Bit

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U686.html

Retrieves specific bits from a UInt value.

```APIDOC
### impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn>

#### type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output

### impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn>

#### type Output = Bn
```

--------------------------------

### impl KeyInit for Poly1305

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/trait.KeyInit.html

Implementation of the KeyInit trait for the Poly1305 type, providing a specific method for initializing Poly1305 with a key.

```APIDOC
### impl KeyInit for Poly1305

#### fn new(key: &GenericArray<u8, <Poly1305 as KeySizeUser>::KeySize>) -> Poly1305

### Description
Initialize Poly1305 with the given key.

### Method
Associated Function

### Parameters
#### Path Parameters
- **key** (&GenericArray<u8, <Poly1305 as KeySizeUser>::KeySize>) - Required - The key to initialize Poly1305 with.
```

--------------------------------

### Get Bit Operation

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U10000000000000.html

Retrieves a specific bit from a `UInt` value.

```APIDOC
## Get Bit Operation for `UInt`

### Description
Retrieves the value of a specific bit within a `UInt` number.

#### Getting a bit from `UInt<Un, Bn>`
- **Associated Type `Output`**: `<Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output`
- **Description**: Retrieves a bit from a `UInt` where the bit position is specified by another `UInt`.

#### Getting a bit from `UInt<Un, Bn>` with `UTerm`
- **Associated Type `Output`**: `Bn`
- **Description**: Retrieves the bit at the `UTerm` position (which is the least significant bit) from a `UInt`.
```

--------------------------------

### Ordering Implementation

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U262143.html

Provides comparison methods for UInt.

```APIDOC
## Ord for UInt<U, B>

### Description
Provides ordering comparisons for UInt.

### Method
#### cmp
`fn cmp(&self, other: &UInt<U, B>) -> Ordering`

Compares `self` and `other` and returns an `Ordering`.
```

```APIDOC
## Ord for UInt<U, B>

### Description
Provides maximum value comparison for UInt.

### Method
#### max
`fn max(self, other: Self) -> Self`

Compares and returns the maximum of two values.
```

```APIDOC
## Ord for UInt<U, B>

### Description
Provides minimum value comparison for UInt.

### Method
#### min
`fn min(self, other: Self) -> Self`

Compares and returns the minimum of two values.
```

```APIDOC
## Ord for UInt<U, B>

### Description
Restricts a value to a certain interval.

### Method
#### clamp
`fn clamp(self, min: Self, max: Self) -> Self`

Restricts a value to be within the specified minimum and maximum bounds.
```

--------------------------------

### Ordering and Comparison (`Ord`, `PartialOrd`, `PartialEq`)

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U514.html

Provides methods for comparing UInt values, including checking for equality, determining order, and finding minimum/maximum values.

```APIDOC
## fn cmp(&self, other: &UInt<U, B>) -> Ordering

This method returns an `Ordering` between `self` and `other`.

### Method
`cmp`

### Parameters
- `other`: `&UInt<U, B>` - The other UInt value to compare against.

### Response
- `Ordering`: An enum value indicating the order relationship (Less, Equal, Greater).
```

```APIDOC
## fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

### Method
`max`

### Parameters
- `other`: `Self` - The other UInt value to compare.

### Response
- `Self`: The maximum of the two UInt values.
```

```APIDOC
## fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

### Method
`min`

### Parameters
- `other`: `Self` - The other UInt value to compare.

### Response
- `Self`: The minimum of the two UInt values.
```

```APIDOC
## fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

### Method
`clamp`

### Parameters
- `min`: `Self` - The minimum allowed value.
- `max`: `Self` - The maximum allowed value.

### Response
- `Self`: The clamped UInt value.
```

```APIDOC
## fn eq(&self, other: &UInt<U, B>) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.

### Method
`eq`

### Parameters
- `other`: `&UInt<U, B>` - The other UInt value to compare.

### Response
- `bool`: `true` if the values are equal, `false` otherwise.
```

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

Tests for `!=`.

### Method
`ne`

### Parameters
- `other`: `&Rhs` - The other value to compare.

### Response
- `bool`: `true` if the values are not equal, `false` otherwise.
```

```APIDOC
## fn partial_cmp(&self, other: &UInt<U, B>) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists.

### Method
`partial_cmp`

### Parameters
- `other`: `&UInt<U, B>` - The other UInt value to compare against.

### Response
- `Option<Ordering>`: An `Option` containing an `Ordering` if the values are comparable, `None` otherwise.
```

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

Tests less than (for `self` and `other`) and is used by the `<` operator.

### Method
`lt`

### Parameters
- `other`: `&Rhs` - The other value to compare.

### Response
- `bool`: `true` if `self` is less than `other`, `false` otherwise.
```

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

Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

### Method
`le`

### Parameters
- `other`: `&Rhs` - The other value to compare.

### Response
- `bool`: `true` if `self` is less than or equal to `other`, `false` otherwise.
```

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

Tests greater than (for `self` and `other`) and is used by the `>` operator.

### Method
`gt`

### Parameters
- `other`: `&Rhs` - The other value to compare.

### Response
- `bool`: `true` if `self` is greater than `other`, `false` otherwise.
```

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

Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.

### Method
`ge`

### Parameters
- `other`: `&Rhs` - The other value to compare.

### Response
- `bool`: `true` if `self` is greater than or equal to `other`, `false` otherwise.
```

--------------------------------

### UInt Get Bit Operation

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U733.html

Retrieves a specific bit from a UInt value.

```APIDOC
## type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output

Source
```

```APIDOC
## type Output = Bn

Source
```

--------------------------------

### Bit Extraction

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U35184372088831.html

Provides methods to get specific bits from a UInt value.

```APIDOC
## Get Bit

### Description
Allows for retrieving the value of a specific bit within a `UInt` number. This is achieved by using a bit index.

### Associated Type
`type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output` (for general `UInt` comparison)
`type Output = Bn` (when comparing against `UTerm`)

The type of the retrieved bit (typically a boolean or a bit representation).
```

--------------------------------

### Ordering Implementations

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U705.html

Provides methods for comparing UInt instances.

```APIDOC
## impl<U, B> Ord for UInt<U, B>

### Description
Provides total ordering for UInt instances.

### Method
`cmp(&self, other: &UInt<U, B>) -> Ordering`
Compares `self` and `other` values.

### Method
`max(self, other: Self) -> Self`
Returns the maximum of two values.

### Method
`min(self, other: Self) -> Self`
Returns the minimum of two values.

### Method
`clamp(self, min: Self, max: Self) -> Self`
Restricts a value to a certain interval.
```

--------------------------------

### Ordering and Comparison Methods

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U58.html

Details the methods for comparing UInt<U, B> instances, including equality, ordering, and clamping values.

```APIDOC
## Ordering and Comparison Methods

### `impl<U, B> Ord for UInt<U, B>`

#### fn cmp(&self, other: &UInt<U, B>) -> Ordering

This method returns an `Ordering` between `self` and `other`.

#### fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#### fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#### fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

### `impl<U, B> PartialEq for UInt<U, B>`

#### fn eq(&self, other: &UInt<U, B>) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.

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

Tests for `!=`.

### `impl<U, B> PartialOrd for UInt<U, B>`

#### fn partial_cmp(&self, other: &UInt<U, B>) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists.

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

Tests less than (for `self` and `other`) and is used by the `<` operator.

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

Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

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

Tests greater than (for `self` and `other`) and is used by the `>` operator.

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

Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.
```

--------------------------------

### Get Bit from UTerm

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1019.html

Retrieves a specific bit from a UInt value when the index is UTerm.

```APIDOC
## type Output = Bn


```

--------------------------------

### Ordering and Comparison

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U510.html

Details the methods for comparing `UInt` values, including total ordering, finding minimum/maximum, and clamping values within a range.

```APIDOC
## Ordering and Comparison

### Description
Provides methods for comparing `UInt` values.

### Methods

#### `fn cmp(&self, other: &UInt<U, B>) -> Ordering`
Compares `self` and `other` and returns an `Ordering`.

#### `fn max(self, other: Self) -> Self`
Returns the maximum of two values.

#### `fn min(self, other: Self) -> Self`
Returns the minimum of two values.

#### `fn clamp(self, min: Self, max: Self) -> Self`
Restricts a value to a specified interval.
```

--------------------------------

### type Output (GetBit)

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U817.html

The output type when getting a specific bit from a UInt value.

```APIDOC
## type Output (GetBit)

### Description
Source

### Signature
`type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output`
```

--------------------------------

### KeyInit Trait Implementation for ChaChaPoly1305

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/type.ChaCha8Poly1305.html

Provides methods for initializing ChaChaPoly1305 with a key, including creating from a fixed-size key, a slice, or generating a random key.

```APIDOC
### impl<C, N> KeyInit for ChaChaPoly1305<C, N>

#### Function: new

```rust
fn new(key: &Key) -> Self
```

**Description**: Create new value from fixed size key.

#### Function: new_from_slice

```rust
fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength>
```

**Description**: Create new value from variable size key.

#### Function: generate_key

```rust
fn generate_key( rng: impl CryptoRng + RngCore, ) -> GenericArray<u8, Self::KeySize>
```

**Availability**: Available on `crate feature 'rand_core'` only.

**Description**: Generate random key using the provided `CryptoRng`.
```

--------------------------------

### Get Bit Operation

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U8796093022207.html

Provides functionality to retrieve a specific bit from a UInt type.

```APIDOC
## impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn>

Retrieves a bit from a UInt type based on another UInt type.
```

```APIDOC
## impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn>

Retrieves a bit from a UInt type when the index is `UTerm`.
```

--------------------------------

### PInt<U> Implementations

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P443.html

Provides details on the implementations available for the generic PInt type, which P443 is an alias for. These include methods for instantiation, arithmetic, comparison, and formatting.

```APIDOC
## Implementations for PInt<U>

### `impl<U> PInt<U> where U: Unsigned + NonZero`

#### `pub fn new() -> PInt<U>`

Instantiates a singleton representing this strictly positive integer.

### Trait Implementations

#### `impl<U> Abs for PInt<U> where U: Unsigned + NonZero`

##### `type Output = PInt<U>`

The absolute value.

#### `impl<Ul, Ur> Add<NInt<Ur>> for PInt<Ul> where Ul: Unsigned + NonZero + Cmp<Ur> + PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>, Ur: Unsigned + NonZero`

##### `type Output = <Ul as PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>>::Output`

The resulting type after applying the `+` operator.

##### `fn add(self, rhs: NInt<Ur>) -> <PInt<Ul> as Add<NInt<Ur>>>::Output`

Performs the `+` operation.

#### `impl<Ul, Ur> Add<PInt<Ur>> for PInt<Ul> where Ul: Unsigned + NonZero + Add<Ur>, Ur: Unsigned + NonZero, <Ul as Add<Ur>>::Output: Unsigned + NonZero`

##### `type Output = PInt<<Ul as Add<Ur>>::Output>`

The resulting type after applying the `+` operator.

##### `fn add(self, _: PInt<Ur>) -> <PInt<Ul> as Add<PInt<Ur>>>::Output`

Performs the `+` operation.

#### `impl<U> Add<Z0> for PInt<U> where U: Unsigned + NonZero`

##### `type Output = PInt<U>`

The resulting type after applying the `+` operator.

##### `fn add(self, _: Z0) -> <PInt<U> as Add<Z0>>::Output`

Performs the `+` operation.

#### `impl<U> Binary for PInt<U> where U: Unsigned + NonZero + Binary`

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

Formats the value using the given formatter.

#### `impl<U> Clone for PInt<U> where U: Clone + Unsigned + NonZero`

##### `fn clone(&self) -> PInt<U>`

Returns a duplicate of the value.

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

Performs copy-assignment from `source`.

#### `impl<P, N> Cmp<NInt<N>> for PInt<P> where P: Unsigned + NonZero, N: Unsigned + NonZero`

##### `type Output = Greater`

The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`.

#### `impl<Pl, Pr> Cmp<PInt<Pr>> for PInt<Pl> where Pl: Cmp<Pr> + Unsigned + NonZero, Pr: Unsigned + NonZero`

##### `type Output = <Pl as Cmp<Pr>>::Output`

The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`.

#### `impl<U> Cmp<Z0> for PInt<U> where U: Unsigned + NonZero`

##### `type Output = Greater`

The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`.

#### `impl<U> Debug for PInt<U> where U: Debug + Unsigned + NonZero`

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

Formats the value using the given formatter.

#### `impl<U> Default for PInt<U> where U: Default + Unsigned + NonZero`

##### `fn default() -> PInt<U>`

Returns the “default value” for a type.

#### `impl<Ul, Ur> Div<NInt<Ur>> for PInt<Ul> where Ul: Unsigned + NonZero + Cmp<Ur>, Ur: Unsigned + NonZero, PInt<Ul>: PrivateDivInt<<Ul as Cmp<Ur>>::Output, NInt<Ur>>`

##### `type Output = <PInt<Ul> as PrivateDivInt<<Ul as Cmp<Ur>>::Output, NInt<Ur>>>::Output`

The resulting type after applying the `/` operator.

##### `fn div(self, rhs: NInt<Ur>) -> <PInt<Ul> as Div<NInt<Ur>>>::Output`

Performs the `/` operation.

#### `impl<Ul, Ur> Div<PInt<Ur>> for PInt<Ul> where Ul: Unsigned + NonZero + Cmp<Ur>, Ur: Unsigned + NonZero, PInt<Ul>: PrivateDivInt<<Ul as Cmp<Ur>>::Output, PInt<Ur>>`

##### `type Output = <PInt<Ul> as PrivateDivInt<<Ul as Cmp<Ur>>::Output, PInt<Ur>>>::Output`

The resulting type after applying the `/` operator.

##### `fn div(self, rhs: PInt<Ur>) -> <PInt<Ul> as Div<PInt<Ur>>>::Output`

Performs the `/` operation.

#### `impl<U1, U2> Gcd<NInt<U2>> for PInt<U1> where U1: Unsigned + NonZero + Gcd<U2>, U2: Unsigned + NonZero, <U1 as Gcd<U2>>::Output: Unsigned + NonZero`

##### `type Output = PInt<<U1 as Gcd<U2>>::Output>`

The greatest common divisor.

#### `impl<U1, U2> Gcd<PInt<U2>> for PInt<U1> where U1: Unsigned + NonZero + Gcd<U2>, U2: Unsigned + NonZero, <U1 as Gcd<U2>>::Output: Unsigned + NonZero`

##### `type Output = PInt<<U1 as Gcd<U2>>::Output>`

The greatest common divisor.

#### `impl<U> Gcd<Z0> for PInt<U> where U: Unsigned + NonZero`
```

--------------------------------

### Get Key Size

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/struct.ChaChaPoly1305.html

Returns the required key size in bytes for the ChaChaPoly1305 algorithm.

```rust
fn key_size() -> usize
```

--------------------------------

### UInt Ordering and Comparison

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U4294967296.html

Details the methods for comparing `UInt` values, including finding minimum, maximum, and clamping values.

```APIDOC
## UInt Ordering and Comparison

This section covers the ordering and comparison functionalities for the `UInt` type.

### `cmp`

Compares `self` with `other` and returns an `Ordering`.

- **Signature**: `fn cmp(&self, other: &UInt<U, B>) -> Ordering`

### `max`

Returns the maximum of two `UInt` values.

- **Signature**: `fn max(self, other: Self) -> Self`

### `min`

Returns the minimum of two `UInt` values.

- **Signature**: `fn min(self, other: Self) -> Self`

### `clamp`

Restricts a `UInt` value to be within a specified interval [`min`, `max`].

- **Signature**: `fn clamp(self, min: Self, max: Self) -> Self`
```

--------------------------------

### Bit for B1 Methods

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/struct.B1.html

Provides methods to get the u8 and bool representations of the B1 bit.

```rust
fn to_u8() -> u8;
fn to_bool() -> bool;

```

--------------------------------

### impl KeyInit for ChaChaPoly1305

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/trait.KeyInit.html

Implementation of the KeyInit trait for the ChaChaPoly1305 type.

```APIDOC
### impl<C, N> KeyInit for ChaChaPoly1305<C, N>

(No specific methods documented for this implementation in the provided text beyond the trait's general methods.)
```

--------------------------------

### Length Calculation for UInt

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U35184372088832.html

Provides a method to get the length of a UInt instance as a type-level unsigned integer.

```APIDOC
## Length Calculation

### Description
Calculates the length of a `UInt` instance. The length is represented as a type-level unsigned integer, determined by the length of the underlying unsigned integer type `U` plus one for the bit `B`.

### Method Signature
`fn len(&self) -> <UInt<U, B> as Len>::Output`

This function isn’t used in this crate, but may be useful for others.

### Associated Type `Output`
`type Output = <<U as Len>::Output as Add<B1>>::Output`

The length as a type-level unsigned integer.
```

--------------------------------

### Get Bit Operation for UInt

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U35184372088832.html

Implements the GetBit operation to retrieve a specific bit from a UInt instance.

```APIDOC
## Get Bit Operation

### Description
Retrieves a specific bit from a `UInt` instance. The operation is defined recursively, with a base case for `UTerm` and a general case for `UInt` types.

### General Case
- **Associated Type `Output`**: `type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output`

### Base Case (`UTerm`)
- **Associated Type `Output`**: `type Output = Bn`

This operation allows for the inspection of individual bits within the `UInt` value.
```

--------------------------------

### Ordering and Comparison Implementations

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U903.html

Provides methods for comparing UInt values, including `cmp`, `max`, `min`, and `clamp`.

```APIDOC
## fn cmp(&self, other: &UInt<U, B>) -> Ordering

### Description
Compares `self` and `other` and returns an `Ordering`.

### Method
`cmp`

### Parameters
- `self`: The first UInt value.
- `other`: The second UInt value to compare against.
```

```APIDOC
## fn max(self, other: Self) -> Self

### Description
Compares two values and returns the maximum.

### Method
`max`

### Parameters
- `self`: The first UInt value.
- `other`: The second UInt value.
```

```APIDOC
## fn min(self, other: Self) -> Self

### Description
Compares two values and returns the minimum.

### Method
`min`

### Parameters
- `self`: The first UInt value.
- `other`: The second UInt value.
```

```APIDOC
## fn clamp(self, min: Self, max: Self) -> Self

### Description
Restricts a value to a certain interval defined by `min` and `max`.

### Method
`clamp`

### Parameters
- `self`: The value to clamp.
- `min`: The minimum allowed value.
- `max`: The maximum allowed value.
```

--------------------------------

### Get Bit with UTerm

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U262143.html

Retrieves a specific bit from a UInt value when the position is `UTerm`. The result is the `Bit` value `Bn`.

```APIDOC
#### type Output = Bn


```

--------------------------------

### PInt<U> Ordering Implementations

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P68719476736.html

Provides methods for comparing PInt<U> instances, including checking for equality, inequality, and determining the order (less than, greater than, equal to, etc.).

```APIDOC
## PInt<U> Ordering and Comparison

### Description
Implements comparison traits for the `PInt<U>` type, allowing instances to be ordered and checked for equality.

### Methods

#### `cmp(&self, other: &PInt<U>) -> Ordering`
Compares `self` with `other` and returns an `Ordering`.

#### `partial_cmp(&self, other: &PInt<U>) -> Option<Ordering>`
Compares `self` with `other` and returns an `Option<Ordering>` if a comparison is possible.

#### `eq(&self, other: &PInt<U>) -> bool`
Tests if `self` is equal to `other`.

#### `ne(&self, other: &Rhs) -> bool`
Tests if `self` is not equal to `other`.

#### `lt(&self, other: &Rhs) -> bool`
Tests if `self` is less than `other`.

#### `le(&self, other: &Rhs) -> bool`
Tests if `self` is less than or equal to `other`.

#### `gt(&self, other: &Rhs) -> bool`
Tests if `self` is greater than `other`.

#### `ge(&self, other: &Rhs) -> bool`
Tests if `self` is greater than or equal to `other`.
```

--------------------------------

### PInt<U> Ordering Implementation

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P2147483647.html

Provides methods for comparing PInt<U> instances, including `cmp` for total ordering, `max` and `min` for finding extremes, and `clamp` for restricting values within an interval.

```APIDOC
## `cmp`

### Description
Compares `self` with `other` and returns an `Ordering`.

### Signature
`fn cmp(&self, other: &PInt<U>) -> Ordering`

## `max`

### Description
Compares `self` and `other` and returns the maximum value.

### Signature
`fn max(self, other: Self) -> Self`

## `min`

### Description
Compares `self` and `other` and returns the minimum value.

### Signature
`fn min(self, other: Self) -> Self`

## `clamp`

### Description
Restricts a value to a certain interval defined by `min` and `max`.

### Signature
`fn clamp(self, min: Self, max: Self) -> Self`
```

--------------------------------

### Get Bit Operation

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1152921504606846976.html

Implements the `GetBit` trait for UInt types, allowing retrieval of a specific bit at a given position.

```APIDOC
## Get Bit Operation

### Description
Provides functionality to retrieve a specific bit from a `UInt` type at a given index. The `Output` type alias indicates the type of the retrieved bit.

### Type Aliases
- `type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output` (for `GetBit<UInt<Ui, Bi>>`)
- `type Output = Bn` (for `GetBit<UTerm>`)
```

--------------------------------

### Ordering Implementations

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U851.html

Provides methods for comparing UInt values, including `cmp`, `max`, `min`, and `clamp`.

```APIDOC
## fn cmp(&self, other: &UInt<U, B>) -> Ordering

### Description
Compares `self` and `other` values and returns an `Ordering`.

### Method
`cmp`

### Parameters
- `self`: A reference to the first UInt value.
- `other`: A reference to the second UInt value.

### Returns
An `Ordering` enum value.
```

```APIDOC
## fn max(self, other: Self) -> Self

### Description
Compares two UInt values and returns the maximum.

### Method
`max`

### Parameters
- `self`: The first UInt value.
- `other`: The second UInt value.

### Returns
The maximum of the two values.
```

```APIDOC
## fn min(self, other: Self) -> Self

### Description
Compares two UInt values and returns the minimum.

### Method
`min`

### Parameters
- `self`: The first UInt value.
- `other`: The second UInt value.

### Returns
The minimum of the two values.
```

```APIDOC
## fn clamp(self, min: Self, max: Self) -> Self

### Description
Restricts a UInt value to a certain interval defined by `min` and `max`.

### Method
`clamp`

### Parameters
- `self`: The value to clamp.
- `min`: The minimum allowed value.
- `max`: The maximum allowed value.

### Returns
The clamped value.
```

--------------------------------

### Integer Conversion (i8)

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1024.html

Converts a UInt to an i8. The `to_int` method provides a way to get the concrete i8 value.

```APIDOC
## fn to_int() -> i8

Method returning the concrete value for the type as i8.

### Returns
The i8 representation of the UInt.
```

--------------------------------

### Integer Conversion (i64)

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1024.html

Converts a UInt to an i64. The `to_int` method provides a way to get the concrete i64 value.

```APIDOC
## fn to_int() -> i64

Method returning the concrete value for the type as i64.

### Returns
The i64 representation of the UInt.
```

--------------------------------

### PInt<U> Implementations

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P692.html

Provides details on the implementations available for the PInt<U> type, which P692 is an alias for. This includes methods for instantiation, arithmetic operations, comparisons, and more.

```APIDOC
## Type Alias P692

`pub type P692 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>>;`

This is a type alias for `PInt` with a specific unsigned integer configuration.

### Aliased Type

```rust
pub struct P692 { /* private fields */ }
```

### Implementations for PInt<U>

#### `pub fn new() -> PInt<U>`
Instantiates a singleton representing this strictly positive integer.

#### `impl<U> Abs for PInt<U>`
- **type Output**: `PInt<U>` - The absolute value.

#### `impl<Ul, Ur> Add<NInt<Ur>> for PInt<Ul>`
- **type Output**: `<Ul as PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>>::Output` - The resulting type after applying the `+` operator.
- **fn add(self, rhs: NInt<Ur>) -> ...**
Performs the `+` operation.

#### `impl<Ul, Ur> Add<PInt<Ur>> for PInt<Ul>`
- **type Output**: `PInt<<Ul as Add<Ur>>::Output>` - The resulting type after applying the `+` operator.
- **fn add(self, _: PInt<Ur>) -> ...**
Performs the `+` operation.

#### `impl<U> Add<Z0> for PInt<U>`
- **type Output**: `PInt<U>` - The resulting type after applying the `+` operator.
- **fn add(self, _: Z0) -> ...**
Performs the `+` operation.

#### `impl<U> Binary for PInt<U>`
- **fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>**
Formats the value using the given formatter.

#### `impl<U> Clone for PInt<U>`
- **fn clone(&self) -> PInt<U>**
Returns a duplicate of the value.
- **fn clone_from(&mut self, source: &Self)**
Performs copy-assignment from `source`.

#### `impl<P, N> Cmp<NInt<N>> for PInt<P>`
- **type Output**: `Greater` - The result of the comparison.

#### `impl<Pl, Pr> Cmp<PInt<Pr>> for PInt<Pl>`
- **type Output**: `<Pl as Cmp<Pr>>::Output` - The result of the comparison.

#### `impl<U> Cmp<Z0> for PInt<U>`
- **type Output**: `Greater` - The result of the comparison.

#### `impl<U> Debug for PInt<U>`
- **fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>**
Formats the value using the given formatter.

#### `impl<U> Default for PInt<U>`
- **fn default() -> PInt<U>**
Returns the “default value” for a type.

#### `impl<Ul, Ur> Div<NInt<Ur>> for PInt<Ul>`
- **type Output**: `<PInt<Ul> as PrivateDivInt<<Ul as Cmp<Ur>>::Output, NInt<Ur>>>::Output` - The resulting type after applying the `/` operator.
- **fn div(self, rhs: NInt<Ur>) -> ...**
Performs the `/` operation.

#### `impl<Ul, Ur> Div<PInt<Ur>> for PInt<Ul>`
- **type Output**: `<PInt<Ul> as PrivateDivInt<<Ul as Cmp<Ur>>::Output, PInt<Ur>>>::Output` - The resulting type after applying the `/` operator.
- **fn div(self, rhs: PInt<Ur>) -> ...**
Performs the `/` operation.

#### `impl<U1, U2> Gcd<NInt<U2>> for PInt<U1>`
- **type Output**: `PInt<<U1 as Gcd<U2>>::Output>` - The greatest common divisor.

#### `impl<U1, U2> Gcd<PInt<U2>> for PInt<U1>`
- **type Output**: `PInt<<U1 as Gcd<U2>>::Output>` - The greatest common divisor.

#### `impl<U> Gcd<Z0> for PInt<U>`

```

--------------------------------

### Integer Conversion (i32)

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1024.html

Converts a UInt to an i32. The `to_int` method provides a way to get the concrete i32 value.

```APIDOC
## fn to_int() -> i32

Method returning the concrete value for the type as i32.

### Returns
The i32 representation of the UInt.
```

--------------------------------

### Ordering Implementations

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U937.html

Provides methods for comparing UInt values.

```APIDOC
## fn cmp(&self, other: &UInt<U, B>) -> Ordering

### Description
Compares `self` and `other` and returns an `Ordering`.

### Method
`cmp`

### Parameters
- `self`: The first UInt value.
- `other`: The second UInt value to compare against.

### Returns
An `Ordering` enum variant (`Less`, `Equal`, `Greater`).
```

```APIDOC
## fn max(self, other: Self) -> Self

### Description
Compares two `UInt` values and returns the maximum.

### Method
`max`

### Parameters
- `self`: The first UInt value.
- `other`: The second UInt value.

### Returns
The maximum of the two `UInt` values.
```

```fn min(self, other: Self) -> Self

### Description
Compares two `UInt` values and returns the minimum.

### Method
`min`

### Parameters
- `self`: The first UInt value.
- `other`: The second UInt value.

### Returns
The minimum of the two `UInt` values.
## fn clamp(self, min: Self, max: Self) -> Self

### Description
Restricts a `UInt` value to be within a specified interval.

### Method
`clamp`

### Parameters
- `self`: The `UInt` value to clamp.
- `min`: The minimum allowed value.
- `max`: The maximum allowed value.

### Returns
The clamped `UInt` value.
```

--------------------------------

### PInt<U> Ordering Implementation

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P486.html

Provides methods for comparing PInt<U> values, including comparison, finding the maximum, and finding the minimum.

```APIDOC
## Ord for PInt<U>

### Description
Implements ordering comparisons for `PInt<U>`.

### Methods
- `cmp(&self, other: &PInt<U>) -> Ordering`: Compares `self` and `other` and returns an `Ordering`.
- `max(self, other: Self) -> Self`: Returns the maximum of two values.
```

--------------------------------

### Integer Conversion (i16)

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U1024.html

Converts a UInt to an i16. The `to_int` method provides a way to get the concrete i16 value.

```APIDOC
## fn to_int() -> i16

Method returning the concrete value for the type as i16.

### Returns
The i16 representation of the UInt.
```

--------------------------------

### ToInt<i32>

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P1048576.html

Provides a constant `INT` and a method `to_int()` to get the concrete `i32` value of a PInt<U> type.

```APIDOC
## ToInt<i32>

### Description
Provides a constant `INT` and a method `to_int()` to get the concrete `i32` value of a PInt<U> type.

### Type Constraints
`where U: Unsigned + NonZero`

### Constant
`INT: i32` - The concrete value for the type. Can be used in `const` contexts.

### Method
`to_int() -> i32` - Method returning the concrete value for the type.
```

--------------------------------

### Comparison (`cmp`, `max`, `min`, `clamp`, `eq`, `ne`, `partial_cmp`, `lt`, `le`, `gt`, `ge`)

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.U516.html

Details the comparison methods available for the UInt type, including ordering, equality, and range clamping.

```APIDOC
## Comparison Operations

This section covers the various comparison operations supported by the `UInt` type.

### `impl<U, B> Ord for UInt<U, B>`

Implements the `Ord` trait for `UInt` types, enabling total ordering comparisons.

#### `fn cmp(&self, other: &UInt<U, B>) -> Ordering`

Compares `self` and `other` and returns an `Ordering`.

#### `fn max(self, other: Self) -> Self`

Returns the maximum of two values.

#### `fn min(self, other: Self) -> Self`

Returns the minimum of two values.

#### `fn clamp(self, min: Self, max: Self) -> Self`

Restricts a value to a certain interval.

### `impl<U, B> PartialEq for UInt<U, B>`

Implements the `PartialEq` trait for `UInt` types, enabling equality checks.

#### `fn eq(&self, other: &UInt<U, B>) -> bool`

Tests if `self` and `other` values are equal.

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

Tests if `self` and `other` values are not equal.

### `impl<U, B> PartialOrd for UInt<U, B>`

Implements the `PartialOrd` trait for `UInt` types, enabling partial ordering comparisons.

#### `fn partial_cmp(&self, other: &UInt<U, B>) -> Option<Ordering>`

Returns an ordering between `self` and `other` if one exists.

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

Tests if `self` is less than `other`.

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

Tests if `self` is less than or equal to `other`.

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

Tests if `self` is greater than `other`.

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

Tests if `self` is greater than or equal to `other`.
```

--------------------------------

### PInt<U> Comparison Methods

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P936.html

Provides methods for comparing PInt<U> values, including finding the minimum, clamping a value within a range, and testing for equality and inequality.

```APIDOC
## PInt<U> Comparison

### Methods

- **`min(self, other: Self) -> Self`**: Compares two values and returns the minimum.
- **`clamp(self, min: Self, max: Self) -> Self`**: Restricts a value to a specified interval.
- **`eq(&self, other: &PInt<U>) -> bool`**: Tests if `self` and `other` values are equal. Used by `==`.
- **`ne(&self, other: &Rhs) -> bool`**: Tests for inequality (`!=`).
- **`partial_cmp(&self, other: &PInt<U>) -> Option<Ordering>`**: Returns an ordering between `self` and `other` if one exists.
- **`lt(&self, other: &Rhs) -> bool`**: Tests if `self` is less than `other`. Used by `<`.
- **`le(&self, other: &Rhs) -> bool`**: Tests if `self` is less than or equal to `other`. Used by `<=`.
- **`gt(&self, other: &Rhs) -> bool`**: Tests if `self` is greater than `other`. Used by `>`.
- **`ge(&self, other: &Rhs) -> bool`**: Tests if `self` is greater than or equal to `other`. Used by `>=`.
```

--------------------------------

### ToInt<i16>

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/consts/type.P1048576.html

Provides a constant `INT` and a method `to_int()` to get the concrete `i16` value of a PInt<U> type.

```APIDOC
## ToInt<i16>

### Description
Provides a constant `INT` and a method `to_int()` to get the concrete `i16` value of a PInt<U> type.

### Type Constraints
`where U: Unsigned + NonZero`

### Constant
`INT: i16` - The concrete value for the type. Can be used in `const` contexts.

### Method
`to_int() -> i16` - Method returning the concrete value for the type.
```