ChaCha20Poly1305

https://docs.rs/chacha20poly1305/latest/chacha20poly1305/
Admin
A pure Rust implementation of ChaCha20Poly1305 (RFC 8439), an Authenticated Encryption with...
Tokens:451,293
Snippets:7,011
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### XChaCha20Poly1305 Usage

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/index.html

Example demonstrating how to initialize an XChaCha20Poly1305 cipher, generate a nonce, and perform encryption and decryption.

```APIDOC
## Rust SDK: XChaCha20Poly1305

### Description
This example demonstrates the standard usage pattern for the XChaCha20Poly1305 AEAD construction, including key generation, nonce generation, and the encryption/decryption process.

### Usage
```rust
use chacha20poly1305::{
    aead::{Aead, AeadCore, Generate, Key, KeyInit},
    XChaCha20Poly1305, XNonce
};

// Initialize cipher
let key = Key::<XChaCha20Poly1305>::generate();
let cipher = XChaCha20Poly1305::new(&key);

// Generate unique nonce
let nonce = XNonce::generate();

// Encrypt
let ciphertext = cipher.encrypt(&nonce, b"plaintext message".as_ref())?;

// Decrypt
let plaintext = cipher.decrypt(&nonce, ciphertext.as_ref())?;
```
```

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

### Generate Key from RNG

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

Example of generating a key using the Generate trait, which replaces the deprecated generate_key method.

```rust
let key = Key::generate_from_rng(rng);
```

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

### ArraySize Implementations

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

Examples of ArraySize trait implementations mapping specific UInt types to fixed-size arrays.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 8192];
}
```

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 4096];
}
```

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 2048];
}
```

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 1024];
}
```

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 512];
}
```

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 640];
}
```

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 768];
}
```

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 896];
}
```

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 256];
}
```

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

### ChaChaPoly1305 Implementation of AeadCore

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

Example implementation of the AeadCore trait for the ChaChaPoly1305 algorithm.

```rust
impl<C, N> AeadCore for ChaChaPoly1305<C, N>
where N: ArraySize,
{
    const TAG_POSITION: TagPosition = TagPosition::Postfix;
    type NonceSize = N;
    type TagSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>;
}
```

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

### Encrypt and Decrypt with XChaCha20Poly1305

Source: https://docs.rs/chacha20poly1305/latest/chacha20poly1305/index.html

Demonstrates the basic workflow for generating a key and nonce, then performing authenticated encryption and decryption. Requires the `getrandom` feature to be enabled.

```rust
// NOTE: requires the `getrandom` feature is enabled

use chacha20poly1305::{
    aead::{Aead, AeadCore, Generate, Key, KeyInit},
    XChaCha20Poly1305, XNonce
};

let key = Key::<XChaCha20Poly1305>::generate();
let cipher = XChaCha20Poly1305::new(&key);
let nonce = XNonce::generate(); // MUST be 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");
```

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

### Implement Binary for UInt

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

Formats the value using the given formatter.

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

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

### KeyInit Trait Definition

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

The core trait definition for types that can be initialized from a key, including required and provided methods.

```rust
pub trait KeyInit: Sized + KeySizeUser {
    // Required method
    fn new(key: &Array<u8, Self::KeySize>) -> Self;

    // Provided methods
    fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength> { ... }
    fn generate_key<R>(rng: &mut R) -> Array<u8, Self::KeySize>
       where R: CryptoRng { ... }
}
```

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

### Implement Min for UInt

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

Provides minimum value comparison for UInt.

```rust
impl<U, B, Ur> Min<Ur> for UInt<U, B>
where U: Unsigned, B: Bit, Ur: Unsigned, UInt<U, B>: Cmp<Ur> + PrivateMin<Ur, <UInt<U, B> as Cmp<Ur>>::Output>,
```

```rust
type Output = <UInt<U, B> as PrivateMin<Ur, <UInt<U, B> as Cmp<Ur>>::Output>>::Output
```

```rust
fn min(self, rhs: Ur) -> <UInt<U, B> as Min<Ur>>::Output
```

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

### Implement Max and Min for UInt

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

Provides comparison-based maximum and minimum operations.

```rust
impl<U, B, Ur> Max<Ur> for UInt<U, B>
where U: Unsigned, B: Bit, Ur: Unsigned, UInt<U, B>: Cmp<Ur> + PrivateMax<Ur, <UInt<U, B> as Cmp<Ur>>::Output>,
```

```rust
impl<U, B, Ur> Min<Ur> for UInt<U, B>
where U: Unsigned, B: Bit, Ur: Unsigned, UInt<U, B>: Cmp<Ur> + PrivateMin<Ur, <UInt<U, B> as Cmp<Ur>>::Output>,
```

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

### Min implementation for PInt

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

Defines minimum operations for PInt against NInt, PInt, and Z0.

```rust
impl<Ul, Ur> Min<NInt<Ur>> for PInt<Ul>
where Ul: Unsigned + NonZero, Ur: Unsigned + NonZero,
```

```rust
type Output = NInt<Ur>;
```

```rust
fn min(self, rhs: NInt<Ur>) -> <PInt<Ul> as Min<NInt<Ur>>>::Output
```

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

```rust
type Output = PInt<<Ul as Min<Ur>>::Output>;
```

```rust
fn min(self, rhs: PInt<Ur>) -> <PInt<Ul> as Min<PInt<Ur>>>::Output
```

```rust
impl<U> Min<Z0> for PInt<U>
where U: Unsigned + NonZero,
```

```rust
type Output = Z0;
```

```rust
fn min(self, rhs: Z0) -> <PInt<U> as Min<Z0>>::Output
```

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

### Implement Ord for UInt

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

Provides ordering and comparison methods for UInt.

```rust
impl<U, B> Ord for UInt<U, B>
where U: Ord, B: Ord,
```

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

```rust
fn max(self, other: Self) -> Self
where Self: Sized,
```

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

```rust
fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,
```

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

### Implement Shl for UTerm

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

Shifting left UInt by UTerm.

```rust
type Output = UInt<U, B>
```

```rust
fn shl(self, _: UTerm) -> <UInt<U, B> as Shl<UTerm>>::Output
```

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

### Implement Sub for Ur

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

Subtracting unsigned integers.

```rust
type Output = <<UInt<Ul, Bl> as PrivateSub<Ur>>::Output as Trim>::Output
```

```rust
fn sub(self, rhs: Ur) -> <UInt<Ul, Bl> as Sub<Ur>>::Output
```

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

### Comparison Implementations for UInt

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

Defines comparison logic for various UInt combinations.

```rust
impl<Ul, Ur> Cmp<UInt<Ur, B0>> for UInt<Ul, B1>
where Ul: Unsigned + PrivateCmp<Ur, Greater>, Ur: Unsigned,
```

```rust
type Output = <Ul as PrivateCmp<Ur, Greater>>::Output
```

```rust
impl<Ul, Ur> Cmp<UInt<Ur, B1>> for UInt<Ul, B1>
where Ul: Unsigned + PrivateCmp<Ur, Equal>, Ur: Unsigned,
```

```rust
type Output = <Ul as PrivateCmp<Ur, Equal>>::Output
```

```rust
impl<U, B> Cmp<UTerm> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = Greater
```

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

### Implement Shl for UInt

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

Shifting left UInt by UInt.

```rust
type Output = <UInt<UInt<U, B>, B0> as Shl<<UInt<Ur, Br> as Sub<B1>>::Output>>::Output
```

```rust
fn shl(self, rhs: UInt<Ur, Br>) -> <UInt<U, B> as Shl<UInt<Ur, Br>>>::Output
```

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

### Integer Conversion Constants and Methods

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

Provides constants and conversion methods for integer types.

```rust
const I8: i8 = U::I8
const I16: i16 = U::I16
const I32: i32 = U::I32
const I64: i64 = U::I64
const ISIZE: isize = U::ISIZE
fn to_i8() -> i8
fn to_i16() -> i16
fn to_i32() -> i32
fn to_i64() -> i64
fn to_isize() -> isize
```

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

### Implement Max for UInt

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

Provides maximum value comparison for UInt.

```rust
impl<U, B, Ur> Max<Ur> for UInt<U, B>
where U: Unsigned, B: Bit, Ur: Unsigned, UInt<U, B>: Cmp<Ur> + PrivateMax<Ur, <UInt<U, B> as Cmp<Ur>>::Output>,
```

```rust
type Output = <UInt<U, B> as PrivateMax<Ur, <UInt<U, B> as Cmp<Ur>>::Output>>::Output
```

```rust
fn max(self, rhs: Ur) -> <UInt<U, B> as Max<Ur>>::Output
```

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

### Implement Shl for B1

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

Shifting left a UInt by a one bit.

```rust
type Output = UInt<UInt<U, B>, B0>
```

```rust
fn shl(self, _: B1) -> <UInt<U, B> as Shl<B1>>::Output
```

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

### Debug and Default traits for UInt

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

Standard Debug and Default trait implementations for UInt.

```rust
impl<U, B> Debug for UInt<U, B>
where U: Debug, B: Debug,
```

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

```rust
impl<U, B> Default for UInt<U, B>
where U: Default, B: Default,
```

```rust
fn default() -> UInt<U, B>
```

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

### ArraySize Implementation

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

Implementation of ArraySize for U40, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 40]
```

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

### Implement Cmp for UInt

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

Provides comparison logic for UInt types.

```rust
type Output = <Ul as PrivateCmp<Ur, Equal>>::Output
```

```rust
type Output = <Ul as PrivateCmp<Ur, Less>>::Output
```

```rust
type Output = Greater
```

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

### Implement ArraySize for U436

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

Implementations of ArraySize for various UInt configurations, including the one corresponding to 436.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0> {
	type ArrayType<T> = [T; 436];
}
```

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

### Implement GetBit for UTerm

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

Provides bit retrieval for UTerm.

```rust
impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn>
where Bn: Copy,
```

```rust
type Output = Bn
```

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

### Implement BitXor for UInt

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

Performs the bitwise XOR operation on unsigned integers.

```rust
type Output = <<UInt<Ul, Bl> as PrivateXor<Ur>>::Output as Trim>::Output
```

```rust
fn bitxor(self, rhs: Ur) -> <UInt<Ul, Bl> as BitXor<Ur>>::Output
```

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

### Implement Mul for UTerm

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

Multiplication implementation for UTerm.

```rust
impl<U, B> Mul<UTerm> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = UTerm
```

```rust
fn mul(self, _: UTerm) -> <UInt<U, B> as Mul<UTerm>>::Output
```

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

### Implement Clone for UInt

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

Provides cloning functionality for UInt types.

```rust
fn clone(&self) -> UInt<U, B>
```

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

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

### Implement Mul for B1

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

Multiplication implementation for B1.

```rust
impl<U, B> Mul<B1> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = UInt<U, B>
```

```rust
fn mul(self, _: B1) -> <UInt<U, B> as Mul<B1>>::Output
```

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

### Implement PartialDiv for UInt

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

Provides partial division functionality for UInt.

```rust
impl<Ul, Bl, Ur, Br> PartialDiv<UInt<Ur, Br>> for UInt<Ul, Bl>
where Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit, UInt<Ul, Bl>: Div<UInt<Ur, Br>> + Rem<UInt<Ur, Br>, Output = UTerm>,
```

```rust
type Output = <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output
```

```rust
fn partial_div( self, rhs: UInt<Ur, Br>, ) -> <UInt<Ul, Bl> as PartialDiv<UInt<Ur, Br>>>::Output
```

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

### Implement ArraySize for U334

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

Implementation of ArraySize for U334, mapping it to a fixed-size array of 334 elements.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0> {
	type ArrayType<T> = [T; 334];
}
```

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

### Implement Shl for B0

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

Shifting left any unsigned by a zero bit.

```rust
type Output = UInt<U, B>
```

```rust
fn shl(self, _: B0) -> <UInt<U, B> as Shl<B0>>::Output
```

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

### ArraySize Implementation for U401

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

Implementation of ArraySize for U401, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>
{
	type ArrayType<T> = [T; 401];
}
```

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

### Debug Implementation for UInt

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

Formats UInt for debugging purposes.

```rust
impl<U, B> Debug for UInt<U, B>
where U: Debug, B: Debug,
```

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

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

### Implement Mul for B0

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

Multiplication implementation for B0.

```rust
impl<U, B> Mul<B0> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = UTerm
```

```rust
fn mul(self, _: B0) -> <UInt<U, B> as Mul<B0>>::Output
```

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

### Implement Shr for UTerm

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

Shifting right UInt by UTerm.

```rust
type Output = UInt<U, B>
```

```rust
fn shr(self, _: UTerm) -> <UInt<U, B> as Shr<UTerm>>::Output
```

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

### ArraySize Implementation

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

Implementation of ArraySize for U76, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>, B0> {
    type ArrayType<T> = [T; 76];
}
```

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

### ArraySize Implementation for U67

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

The implementation of ArraySize for U67, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 67]
```

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

### Implement ArraySize for U736

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

Implementation of ArraySize for the U736 type, mapping it to an array of size 736.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0> {
	type ArrayType<T> = [T; 736];
}
```

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

### ArraySize Implementation

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

Implementation of ArraySize for U79, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 79]
```

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

### Implement ArraySize for U440

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

Implementation of ArraySize for the U440 type, mapping it to an array of size 440.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0> {
	type ArrayType<T> = [T; 440];
}
```

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

### Implement ArraySize for U273

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

Implementation of ArraySize for U273, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 273]
```

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

### Integer conversion for PInt

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

Provides constants and conversion methods to standard integer types.

```rust
impl<U> Integer for PInt<U>
where U: Unsigned + NonZero,
```

```rust
const I8: i8 = U::I8;
const I16: i16 = U::I16;
const I32: i32 = U::I32;
const I64: i64 = U::I64;
const ISIZE: isize = U::ISIZE;
```

```rust
fn to_i8() -> i8;
fn to_i16() -> i16;
fn to_i32() -> i32;
fn to_i64() -> i64;
fn to_isize() -> isize;
```

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

### Implement GetBit for UInt

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

Provides bit retrieval functionality for UInt types.

```rust
impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn>
where UInt<Ui, Bi>: Copy + Sub<B1>, Un: GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>,
```

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

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

### Implement Hash for UInt

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

Provides hashing functionality for UInt types.

```rust
impl<U, B> Hash for UInt<U, B>
where U: Hash, B: Hash,
```

```rust
fn hash<__H>(&self, state: &mut __H)
where __H: Hasher,
```

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

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

### Implement ArraySize for U704

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

Implementation of ArraySize for the U704 type, mapping it to an array of size 704.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0> {
	type ArrayType<T> = [T; 704];
}
```

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

### ArraySize Implementation

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

Implementation of ArraySize for U17, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 17]
```

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

### ArraySize Implementation for U368

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

Implementation of ArraySize for U368, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>
{
    type ArrayType<T> = [T; 368];
}
```

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

### Left Shift Operations for UInt

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

Implements Shl for various types including B0, B1, UInt, and UTerm.

```rust
impl<U, B> Shl<B0> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = UInt<U, B>
```

```rust
fn shl(self, _: B0) -> <UInt<U, B> as Shl<B0>>::Output
```

```rust
impl<U, B> Shl<B1> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = UInt<UInt<U, B>, B0>
```

```rust
fn shl(self, _: B1) -> <UInt<U, B> as Shl<B1>>::Output
```

```rust
impl<U, B, Ur, Br> Shl<UInt<Ur, Br>> for UInt<U, B>
where U: Unsigned, B: Bit, Ur: Unsigned, Br: Bit, UInt<Ur, Br>: Sub<B1>, UInt<UInt<U, B>, B0>: Shl<<UInt<Ur, Br> as Sub<B1>>::Output>,
```

```rust
type Output = <UInt<UInt<U, B>, B0> as Shl<<UInt<Ur, Br> as Sub<B1>>::Output>>::Output
```

```rust
fn shl(self, rhs: UInt<Ur, Br>) -> <UInt<U, B> as Shl<UInt<Ur, Br>>>::Output
```

```rust
impl<U, B> Shl<UTerm> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = UInt<U, B>
```

```rust
fn shl(self, _: UTerm) -> <UInt<U, B> as Shl<UTerm>>::Output
```

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

### Implement BitAnd for UInt

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

Performs the bitwise AND operation on unsigned integers.

```rust
type Output = <<UInt<Ul, Bl> as PrivateAnd<Ur>>::Output as Trim>::Output
```

```rust
fn bitand(self, rhs: Ur) -> <UInt<Ul, Bl> as BitAnd<Ur>>::Output
```

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

### GCD implementation for PInt

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

Provides greatest common divisor implementations for PInt with NInt, PInt, and Z0.

```rust
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,
```

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

```rust
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,
```

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

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

### Implement ArraySize for U656

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

Implementation of ArraySize for the U656 type, mapping it to an array of size 656.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0> {
	type ArrayType<T> = [T; 656];
}
```

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

### ArraySize Implementation for U151

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

Implementation of ArraySize for U151, mapping it to an array of size 151.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B1> {
	type ArrayType<T> = [T; 151];
}
```

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

### ArraySize Implementation for U457

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

Implementation of ArraySize for the U457 type, mapping it to an array of size 457.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>
{
	type ArrayType<T> = [T; 457];
}
```

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

### ArraySize Implementation for U624

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

Implementation of ArraySize for U624, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 624];
}
```

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

### ArraySize Implementation for U71

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

Implementation of ArraySize for U71, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 71]
```

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

### Left shift by UTerm for UInt

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

Shifting left UInt by UTerm.

```rust
impl<U, B> Shl<UTerm> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = UInt<U, B>
```

```rust
fn shl(self, _: UTerm) -> <UInt<U, B> as Shl<UTerm>>::Output
```

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

### Implement Mul for UInt

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

Multiplication implementation for UInt types.

```rust
impl<Ul, B, Ur> Mul<UInt<Ur, B>> for UInt<Ul, B0>
where Ul: Unsigned + Mul<UInt<Ur, B>>, B: Bit, Ur: Unsigned,
```

```rust
type Output = UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0>
```

```rust
fn mul(self, rhs: UInt<Ur, B>) -> <UInt<Ul, B0> as Mul<UInt<Ur, B>>>::Output
```

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

### Declare U740 Struct

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

The underlying struct definition for U740.

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

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

### ArraySize Implementation for U310

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

Implementation of ArraySize for U310, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B0>
{
	type ArrayType<T> = [T; 310];
}
```

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

### Implement ArraySize for U560

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

Implementation of ArraySize for the U560 type, mapping it to an array of size 560.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 560];
}
```

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

### ArraySize Implementation for U38

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

Implementation of ArraySize for U38, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0> {
	type ArrayType<T> = [T; 38];
}
```

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

### Implement Default for UInt

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

Returns the default value for the UInt type.

```rust
fn default() -> UInt<U, B>
```

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

### Multiplication by UTerm for UInt

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

Handles multiplication of UInt by UTerm, resulting in UTerm.

```rust
type Output = UTerm
```

```rust
fn mul(self, _: UTerm) -> <UInt<U, B> as Mul<UTerm>>::Output
```

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

### ArraySize Implementation for U544

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

Implementation of ArraySize for U544, mapping it to an array of size 544.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 544];
}
```

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

### Implement Shr for B1

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

Shifting right a UInt by a 1 bit.

```rust
type Output = U
```

```rust
fn shr(self, _: B1) -> <UInt<U, B> as Shr<B1>>::Output
```

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

### Implement BitOr for UInt

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

Performs bitwise OR operations for various UInt combinations.

```rust
type Output = UInt<<Ul as BitOr<Ur>>::Output, B0>
fn bitor( self, rhs: UInt<Ur, B0>, ) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B0>>>::Output
```

```rust
type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>
fn bitor( self, rhs: UInt<Ur, B1>, ) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B1>>>::Output
```

```rust
type Output = UInt<U, B>
fn bitor(self, _: UTerm) -> <UInt<U, B> as BitOr<UTerm>>::Output
```

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

### Implement Len for UInt

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

Calculates the length of a bit sequence.

```rust
impl<U, B> Len for UInt<U, B>
where U: Unsigned + Len, B: Bit, <U as Len>::Output: Add<B1>, <<U as Len>::Output as Add<B1>>::Output: Unsigned,
```

```rust
type Output = <<U as Len>::Output as Add<B1>>::Output
```

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

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

### N430 Struct Definition

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

The underlying struct definition for N430.

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

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

### ArraySize Implementation for U106

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

Implementation of ArraySize for U106, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 106]
```

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

### Right shift by UTerm for UInt

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

Shifting right UInt by UTerm.

```rust
impl<U, B> Shr<UTerm> for UInt<U, B>
where U: Unsigned, B: Bit,
```

```rust
type Output = UInt<U, B>
```

```rust
fn shr(self, _: UTerm) -> <UInt<U, B> as Shr<UTerm>>::Output
```

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

### Represent P433 as a struct

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

The underlying struct representation for the P433 type.

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

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

### ArraySize Implementation for U97

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

Implementation of ArraySize for U97, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 97]
```

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

### ArraySize Implementation for U409

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

Implementation of ArraySize for the U409 type, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B1> {
	type ArrayType<T> = [T; 409];
}
```

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

### Implement ArraySize for U456

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

Implementation of ArraySize for the U456 type, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>
{
	type ArrayType<T> = [T; 456];
}
```

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

### Implement Shr for UInt

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

Shifting right UInt by UInt.

```rust
type Output = <U as Shr<<UInt<Ur, Br> as Sub<B1>>::Output>>::Output
```

```rust
fn shr(self, rhs: UInt<Ur, Br>) -> <UInt<U, B> as Shr<UInt<Ur, Br>>>::Output
```

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

### ArraySize Implementation for U102

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

Implementation of ArraySize for U102, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 102]
```

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

### ArraySize Implementation

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

Implementation of ArraySize for U111, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 111]
```

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

### ArraySize Implementation for U101

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

Implementation of ArraySize for U101, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B1> {
    type ArrayType<T> = [T; 101];
}
```

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

### ArraySize Implementation

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

Implementation of ArraySize for U80, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 80]
```

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

### ArraySize Implementation for U93

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

Implementation of ArraySize for U93, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 93]
```

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

### ArraySize Implementation for U171

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

Implementation of ArraySize for U171, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B1>
{
	type ArrayType<T> = [T; 171];
}
```

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

### ArraySize Implementation for U800

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

Implementation of ArraySize for the U800 type, mapping it to an array of size 800.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0> {
    type ArrayType<T> = [T; 800];
}
```

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

### ArraySize Implementation for U351

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

Implementation of ArraySize for U351, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 351]
```

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

### ArraySize Implementation for U864

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

Implementation of ArraySize for the U864 type, mapping it to an array of size 864.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0> {
	type ArrayType<T> = [T; 864];
}
```

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

### ArraySize Implementation for U269

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

Implementation of ArraySize for U269, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 269]
```

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

### Define P60 Struct

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

The underlying struct definition for P60.

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

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

### Max implementation for PInt

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

Defines maximum operations for PInt against NInt, PInt, and Z0.

```rust
impl<Ul, Ur> Max<NInt<Ur>> for PInt<Ul>
where Ul: Unsigned + NonZero, Ur: Unsigned + NonZero,
```

```rust
type Output = PInt<Ul>;
```

```rust
fn max(self, _: NInt<Ur>) -> <PInt<Ul> as Max<NInt<Ur>>>::Output
```

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

```rust
type Output = PInt<<Ul as Max<Ur>>::Output>;
```

```rust
fn max(self, rhs: PInt<Ur>) -> <PInt<Ul> as Max<PInt<Ur>>>::Output
```

```rust
impl<U> Max<Z0> for PInt<U>
where U: Unsigned + NonZero,
```

```rust
type Output = PInt<U>;
```

```rust
fn max(self, _: Z0) -> <PInt<U> as Max<Z0>>::Output
```

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

### ArraySize Implementation for U109

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

Implementation of ArraySize for U109, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 109]
```

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

### ArraySize Implementation for U316

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

Implementation of ArraySize for U316, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B0> {
	type ArrayType<T> = [T; 316];
}
```

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

### ArraySize Implementation for U75

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

Implementation of ArraySize for U75, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1> {
	type ArrayType<T> = [T; 75];
}
```

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

### Left shift by UInt for UInt

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

Shifting left UInt by UInt.

```rust
impl<U, B, Ur, Br> Shl<UInt<Ur, Br>> for UInt<U, B>
where U: Unsigned, B: Bit, Ur: Unsigned, Br: Bit, UInt<Ur, Br>: Sub<B1>, UInt<UInt<U, B>, B0>: Shl<<UInt<Ur, Br> as Sub<B1>>::Output>,
```

```rust
type Output = <UInt<UInt<U, B>, B0> as Shl<<UInt<Ur, Br> as Sub<B1>>::Output>>::Output
```

```rust
fn shl(self, rhs: UInt<Ur, Br>) -> <UInt<U, B> as Shl<UInt<Ur, Br>>>::Output
```

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

### Declare P642 Struct

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

The underlying struct definition for P642.

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

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

### ArraySize Implementation for U6

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

Implementation of ArraySize for U6, defining the corresponding array type.

```rust
impl ArraySize for UInt<UInt<UInt<UTerm, B1>, B1>, B0> {
    type ArrayType<T> = [T; 6];
}
```

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

### ArraySize Implementation for U195

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

Implementation of ArraySize for U195, defining the corresponding array type size.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1> {
	type ArrayType<T> = [T; 195];
}
```

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

### ArraySize Implementation for U944

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

Implementation of ArraySize for the U944 type, mapping it to an array of size 944.

```rust
impl ArraySize for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>
Source§
#### type ArrayType<T> = [T; 944]
Array type which corresponds to this size. Read more
```

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

### ArraySize Implementation for U30

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

Implementation of ArraySize for U30, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 30]
```

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

### Multiplication by B0 for UInt

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

Handles multiplication of UInt by B0, resulting in UTerm.

```rust
type Output = UTerm
```

```rust
fn mul(self, _: B0) -> <UInt<U, B> as Mul<B0>>::Output
```

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

### ArraySize Implementation for U332

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

Implementation of ArraySize for U332, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 332]
```

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

### Declare U434 Struct

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

The underlying struct definition for U434.

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

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

### ArraySize Implementation for U50

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

Implementation of ArraySize for U50, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 50]
```

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

### N600 Struct Definition

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

The internal structure definition for N600.

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

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

### U37 Array Size Implementation

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

Implementation of ArraySize for U37, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 37]
```

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

### Implement Shr for B0

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

Shifting right any unsigned by a zero bit.

```rust
type Output = UInt<U, B>
```

```rust
fn shr(self, _: B0) -> <UInt<U, B> as Shr<B0>>::Output
```

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

### Max and Min trait implementations for UInt

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

Provides methods to determine the maximum or minimum of two UInt values.

```rust
fn max(self, rhs: Ur) -> <UInt<U, B> as Max<Ur>>::Output
```

```rust
fn min(self, rhs: Ur) -> <UInt<U, B> as Min<Ur>>::Output
```

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

### Declare U701 Struct

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

The internal structure definition for U701.

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

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

### Integer Trait Implementation for PInt

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

Provides integer conversion methods for PInt.

```rust
impl<U> Integer for PInt<U>
where U: Unsigned + NonZero,
```

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

### ArraySize Implementation for U349

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

Implementation of ArraySize for U349, defining the corresponding array type.

```rust
type ArrayType<T> = [T; 349]
```

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

### Implement Div for UInt

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

Performs division operations on UInt types.

```rust
type Output = <() as PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>>::Quotient
```

```rust
fn div(self, rhs: UInt<Ur, Br>) -> <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output
```
Tokens:
Raw