Struct Uint 

pub struct Uint<const LIMBS: usize> { /* private fields */ }

Stack-allocated big unsigned integer.

Generic over the given number of LIMBS

Encoding support

This type supports many different types of encodings, either via the Encoding trait or various const fn decoding and encoding functions that can be used with Uint constants.

Optional crate features for encoding (off-by-default):

• generic-array: enables ArrayEncoding trait which can be used to Uint as GenericArray<u8, N> and a ArrayDecoding trait which can be used to GenericArray<u8, N> as Uint.
• rlp: support for Recursive Length Prefix (RLP) encoding.

Implementations

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn adc(&self, rhs: &Uint<LIMBS>, carry: Limb) -> (Uint<LIMBS>, Limb)

Computes a + b + carry, returning the result along with the new carry.

pub const fn saturating_add(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform saturating addition, returning MAX on overflow.

pub const fn wrapping_add(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping addition, discarding overflow.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn add_mod(&self, rhs: &Uint<LIMBS>, p: &Uint<LIMBS>) -> Uint<LIMBS>

Computes self + rhs mod p.

Assumes self + rhs as unbounded integer is < 2p.

pub const fn add_mod_special(&self, rhs: &Uint<LIMBS>, c: Limb) -> Uint<LIMBS>

Computes self + rhs mod p for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

Assumes self + rhs as unbounded integer is < 2p.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn bitand(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Computes bitwise a & b.

pub const fn wrapping_and(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping bitwise AND.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_and(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked bitwise AND, returning a CtOption which is_some always

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn not(&self) -> Uint<LIMBS>

Computes bitwise !a.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn bitor(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Computes bitwise a & b.

pub const fn wrapping_or(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping bitwise OR.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_or(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked bitwise OR, returning a CtOption which is_some always

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn bitxor(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Computes bitwise a ^ b.

pub const fn wrapping_xor(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping bitwise `XOR``.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_xor(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked bitwise XOR, returning a CtOption which is_some always

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn bit_vartime(&self, index: usize) -> bool

Returns true if the bit at position index is set, false otherwise.

Remarks

This operation is variable time with respect to index only.

pub const fn bits_vartime(&self) -> usize

Calculate the number of bits needed to represent this number.

pub const fn leading_zeros(&self) -> usize

Calculate the number of leading zeros in the binary representation of this number.

pub const fn leading_zeros_vartime(&self) -> usize

Calculate the number of leading zeros in the binary representation of this number, variable time in self.

pub const fn trailing_zeros(&self) -> usize

Calculate the number of trailing zeros in the binary representation of this number.

pub const fn trailing_zeros_vartime(&self) -> usize

Calculate the number of trailing zeros in the binary representation of this number, variable time in self.

pub const fn trailing_ones(&self) -> usize

Calculate the number of trailing ones in the binary representation of this number.

pub const fn trailing_ones_vartime(&self) -> usize

Calculate the number of trailing ones in the binary representation of this number, variable time in self.

pub const fn bits(&self) -> usize

Calculate the number of bits needed to represent this number.

pub const fn bit(&self, index: usize) -> CtChoice

Get the value of the bit at position index, as a truthy or falsy CtChoice. Returns the falsy value for indices out of range.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn cmp_vartime(&self, rhs: &Uint<LIMBS>) -> Ordering

Returns the Ordering between self and rhs in variable time.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn ct_div_rem_limb_with_reciprocal( &self, reciprocal: &Reciprocal, ) -> (Uint<LIMBS>, Limb)

Computes self / rhs using a pre-made reciprocal, returns the quotient (q) and remainder (r).

pub fn div_rem_limb_with_reciprocal( &self, reciprocal: &CtOption<Reciprocal>, ) -> CtOption<(Uint<LIMBS>, Limb)>

Computes self / rhs using a pre-made reciprocal, returns the quotient (q) and remainder (r).

pub fn div_rem_limb(&self, rhs: NonZero<Limb>) -> (Uint<LIMBS>, Limb)

Computes self / rhs, returns the quotient (q) and remainder (r).

pub const fn const_rem(&self, rhs: &Uint<LIMBS>) -> (Uint<LIMBS>, CtChoice)

Computes self % rhs, returns the remainder and and the truthy value for is_some or the falsy value for is_none.

NOTE: Use only if you need to access const fn. Otherwise use Self::rem. This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub const fn const_rem_wide( lower_upper: (Uint<LIMBS>, Uint<LIMBS>), rhs: &Uint<LIMBS>, ) -> (Uint<LIMBS>, CtChoice)

Computes self % rhs, returns the remainder and and the truthy value for is_some or the falsy value for is_none.

This is variable only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

pub const fn rem2k(&self, k: usize) -> Uint<LIMBS>

Computes self % 2^k. Faster than reduce since its a power of 2. Limited to 2^16-1 since Uint doesn’t support higher.

pub fn div_rem(&self, rhs: &NonZero<Uint<LIMBS>>) -> (Uint<LIMBS>, Uint<LIMBS>)

Computes self / rhs, returns the quotient, remainder.

pub fn rem(&self, rhs: &NonZero<Uint<LIMBS>>) -> Uint<LIMBS>

Computes self % rhs, returns the remainder.

pub const fn wrapping_div(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Wrapped division is just normal division i.e. self / rhs There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

Panics if rhs == 0.

pub fn checked_div(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked division, returning a CtOption which is_some only if the rhs != 0

pub const fn wrapping_rem(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Wrapped (modular) remainder calculation is just self % rhs. There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

Panics if rhs == 0.

pub fn checked_rem(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked reduction, returning a CtOption which is_some only if the rhs != 0

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn from_be_slice(bytes: &[u8]) -> Uint<LIMBS>

Create a new Uint from the provided big endian bytes.

pub const fn from_be_hex(hex: &str) -> Uint<LIMBS>

Create a new Uint from the provided big endian hex string.

pub const fn from_le_slice(bytes: &[u8]) -> Uint<LIMBS>

Create a new Uint from the provided little endian bytes.

pub const fn from_le_hex(hex: &str) -> Uint<LIMBS>

Create a new Uint from the provided little endian hex string.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn from_u8(n: u8) -> Uint<LIMBS>

Create a Uint from a u8 (const-friendly)

pub const fn from_u16(n: u16) -> Uint<LIMBS>

Create a Uint from a u16 (const-friendly)

pub const fn from_u32(n: u32) -> Uint<LIMBS>

Create a Uint from a u32 (const-friendly)

pub const fn from_u64(n: u64) -> Uint<LIMBS>

Create a Uint from a u64 (const-friendly)

pub const fn from_u128(n: u128) -> Uint<LIMBS>

Create a Uint from a u128 (const-friendly)

pub const fn from_word(n: u64) -> Uint<LIMBS>

Create a Uint from a Word (const-friendly)

pub const fn from_wide_word(n: u128) -> Uint<LIMBS>

Create a Uint from a WideWord (const-friendly)

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn inv_mod2k_vartime(&self, k: usize) -> Uint<LIMBS>

Computes 1/self mod 2^k. This method is constant-time w.r.t. self but not k.

Conditions: self < 2^k and self must be odd

pub const fn inv_mod2k(&self, k: usize) -> Uint<LIMBS>

Computes 1/self mod 2^k.

Conditions: self < 2^k and self must be odd

pub const fn inv_odd_mod_bounded( &self, modulus: &Uint<LIMBS>, bits: usize, modulus_bits: usize, ) -> (Uint<LIMBS>, CtChoice)

Computes the multiplicative inverse of self mod modulus, where modulus is odd. In other words self^-1 mod modulus. bits and modulus_bits are the bounds on the bit size of self and modulus, respectively (the inversion speed will be proportional to bits + modulus_bits). The second element of the tuple is the truthy value if an inverse exists, otherwise it is a falsy value.

Note: variable time in bits and modulus_bits.

The algorithm is the same as in GMP 6.2.1’s mpn_sec_invert.

pub const fn inv_odd_mod( &self, modulus: &Uint<LIMBS>, ) -> (Uint<LIMBS>, CtChoice)

Computes the multiplicative inverse of self mod modulus, where modulus is odd. Returns (inverse, CtChoice::TRUE) if an inverse exists, otherwise (undefined, CtChoice::FALSE).

pub const fn inv_mod(&self, modulus: &Uint<LIMBS>) -> (Uint<LIMBS>, CtChoice)

Computes the multiplicative inverse of self mod modulus. Returns (inverse, CtChoice::TRUE) if an inverse exists, otherwise (undefined, CtChoice::FALSE).

impl<const LIMBS: usize> Uint<LIMBS>

pub fn mul<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS>, ) -> <Uint<HLIMBS> as ConcatMixed<Uint<LIMBS>>>::MixedOutput

where Uint<HLIMBS>: ConcatMixed<Uint<LIMBS>>,

Multiply self by rhs, returning a concatenated “wide” result.

pub const fn mul_wide<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS>, ) -> (Uint<LIMBS>, Uint<HLIMBS>)

Compute “wide” multiplication, with a product twice the size of the input.

Returns a tuple containing the (lo, hi) components of the product.

Ordering note

Releases of crypto-bigint prior to v0.3 used (hi, lo) ordering instead. This has been changed for better consistency with the rest of the APIs in this crate.

For more info see: https://github.com/RustCrypto/crypto-bigint/issues/4

pub const fn saturating_mul<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS>, ) -> Uint<LIMBS>

Perform saturating multiplication, returning MAX on overflow.

pub const fn wrapping_mul<const H: usize>(&self, rhs: &Uint<H>) -> Uint<LIMBS>

Perform wrapping multiplication, discarding overflow.

pub fn square(&self) -> <Uint<LIMBS> as Concat>::Output

where Uint<LIMBS>: Concat,

Square self, returning a concatenated “wide” result.

pub const fn square_wide(&self) -> (Uint<LIMBS>, Uint<LIMBS>)

Square self, returning a “wide” result in two parts as (lo, hi).

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn mul_mod_special(&self, rhs: &Uint<LIMBS>, c: Limb) -> Uint<LIMBS>

Computes self * rhs mod p for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb. For the modulus reduction, this function implements Algorithm 14.47 from the “Handbook of Applied Cryptography”, by A. Menezes, P. van Oorschot, and S. Vanstone, CRC Press, 1996.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn wrapping_neg(&self) -> Uint<LIMBS>

Perform wrapping negation.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn neg_mod(&self, p: &Uint<LIMBS>) -> Uint<LIMBS>

Computes -a mod p. Assumes self is in [0, p).

pub const fn neg_mod_special(&self, c: Limb) -> Uint<LIMBS>

Computes -a mod p for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn resize<const T: usize>(&self) -> Uint<T>

Construct a Uint<T> from the unsigned integer value, truncating the upper bits if the value is too large to be represented.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn shl_vartime(&self, n: usize) -> Uint<LIMBS>

Computes self << shift.

NOTE: this operation is variable time with respect to n ONLY.

When used with a fixed n, this function is constant-time with respect to self.

pub const fn shl_vartime_wide( lower_upper: (Uint<LIMBS>, Uint<LIMBS>), n: usize, ) -> (Uint<LIMBS>, Uint<LIMBS>)

Computes a left shift on a wide input as (lo, hi).

NOTE: this operation is variable time with respect to n ONLY.

When used with a fixed n, this function is constant-time with respect to self.

pub const fn shl(&self, shift: usize) -> Uint<LIMBS>

Computes self << n. Returns zero if n >= Self::BITS.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn shr_vartime(&self, shift: usize) -> Uint<LIMBS>

Computes self >> n.

NOTE: this operation is variable time with respect to n ONLY.

When used with a fixed n, this function is constant-time with respect to self.

pub const fn shr_vartime_wide( lower_upper: (Uint<LIMBS>, Uint<LIMBS>), n: usize, ) -> (Uint<LIMBS>, Uint<LIMBS>)

Computes a right shift on a wide input as (lo, hi).

NOTE: this operation is variable time with respect to n ONLY.

When used with a fixed n, this function is constant-time with respect to self.

pub const fn shr(&self, shift: usize) -> Uint<LIMBS>

Computes self << n. Returns zero if n >= Self::BITS.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn sqrt(&self) -> Uint<LIMBS>

👎Deprecated since 0.5.3: This functionality will be moved to sqrt_vartime in a future release.

See Self::sqrt_vartime.

pub const fn sqrt_vartime(&self) -> Uint<LIMBS>

Computes √(self) Uses Brent & Zimmermann, Modern Computer Arithmetic, v0.5.9, Algorithm 1.13

Callers can check if self is a square by squaring the result

pub const fn wrapping_sqrt(&self) -> Uint<LIMBS>

👎Deprecated since 0.5.3: This functionality will be moved to wrapping_sqrt_vartime in a future release.

See Self::wrapping_sqrt_vartime.

pub const fn wrapping_sqrt_vartime(&self) -> Uint<LIMBS>

Wrapped sqrt is just normal √(self) There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

pub fn checked_sqrt(&self) -> CtOption<Uint<LIMBS>>

👎Deprecated since 0.5.3: This functionality will be moved to checked_sqrt_vartime in a future release.

See Self::checked_sqrt_vartime.

pub fn checked_sqrt_vartime(&self) -> CtOption<Uint<LIMBS>>

Perform checked sqrt, returning a CtOption which is_some only if the √(self)² == self

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn sbb(&self, rhs: &Uint<LIMBS>, borrow: Limb) -> (Uint<LIMBS>, Limb)

Computes a - (b + borrow), returning the result along with the new borrow.

pub const fn saturating_sub(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform saturating subtraction, returning ZERO on underflow.

pub const fn wrapping_sub(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping subtraction, discarding underflow and wrapping around the boundary of the type.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn sub_mod(&self, rhs: &Uint<LIMBS>, p: &Uint<LIMBS>) -> Uint<LIMBS>

Computes self - rhs mod p.

Assumes self - rhs as unbounded signed integer is in [-p, p).

pub const fn sub_mod_special(&self, rhs: &Uint<LIMBS>, c: Limb) -> Uint<LIMBS>

Computes self - rhs mod p for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

Assumes self - rhs as unbounded signed integer is in [-p, p).

impl<const LIMBS: usize> Uint<LIMBS>

pub const ZERO: Uint<LIMBS>

The value 0.

pub const ONE: Uint<LIMBS>

The value 1.

pub const MAX: Uint<LIMBS>

Maximum value this Uint can express.

pub const BITS: usize

Total size of the represented integer in bits.

pub const BYTES: usize

Total size of the represented integer in bytes.

pub const LIMBS: usize = LIMBS

The number of limbs used on this platform.

pub const fn new(limbs: [Limb; LIMBS]) -> Uint<LIMBS>

Const-friendly Uint constructor.

pub const fn from_words(arr: [u64; LIMBS]) -> Uint<LIMBS>

Create a Uint from an array of Words (i.e. word-sized unsigned integers).

pub const fn to_words(self) -> [u64; LIMBS]

Create an array of Words (i.e. word-sized unsigned integers) from a Uint.

pub const fn as_words(&self) -> &[u64; LIMBS]

Borrow the inner limbs as an array of Words.

pub fn as_words_mut(&mut self) -> &mut [u64; LIMBS]

Borrow the inner limbs as a mutable array of Words.

pub const fn as_limbs(&self) -> &[Limb; LIMBS]

Borrow the limbs of this Uint.

pub fn as_limbs_mut(&mut self) -> &mut [Limb; LIMBS]

Borrow the limbs of this Uint mutably.

pub const fn to_limbs(self) -> [Limb; LIMBS]

Convert this Uint into its inner limbs.

impl Uint<crypto_bigint::::uint::{impl#49}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#49}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U128::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U128::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#52}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#52}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#54}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#54}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U256::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#57}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#57}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#59}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#59}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U384::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U384::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#62}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#62}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#64}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#64}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U512::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U512::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#67}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#67}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#69}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#69}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U640::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#72}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#72}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#74}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#74}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U768::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#77}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#77}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#79}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#79}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U896::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#82}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#82}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#84}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#84}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U1024::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#87}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#87}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#89}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#89}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U1280::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U1280::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#92}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#92}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#94}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#94}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U1536::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U1536::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#97}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#97}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#99}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#99}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U1792::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U1792::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#102}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#102}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#104}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#104}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U2048::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U2048::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#107}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#107}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#109}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#109}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U3072::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U3072::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#112}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#112}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#114}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#114}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U3584::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U3584::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#117}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#117}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#119}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#119}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U4096::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U4096::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#122}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#122}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#124}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#124}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U4224::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U4224::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#127}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#127}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#129}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#129}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U4352::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U4352::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#132}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#132}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#134}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#134}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U6144::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U6144::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#137}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#137}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#139}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#139}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U8192::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U8192::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#142}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#142}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

impl Uint<crypto_bigint::::uint::{impl#144}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#144}::concat::{constant#0}>, ) -> Uint<crypto_bigint::::uint::U16384::{constant#0}>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Uint<crypto_bigint::::uint::U16384::{constant#0}>

pub const fn split( &self, ) -> (Uint<crypto_bigint::::uint::{impl#147}::split::{constant#0}>, Uint<crypto_bigint::::uint::{impl#147}::split::{constant#1}>)

Split this number in half, returning its high and low components respectively.

Trait Implementations

impl<const LIMBS: usize> AddMod for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn add_mod(&self, rhs: &Uint<LIMBS>, p: &Uint<LIMBS>) -> Uint<LIMBS>

Compute self + rhs mod p.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U1024::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U1024::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U1024::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U1024::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U1024::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U1024::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U1024::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U128::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U128::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U128::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U128::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U128::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U128::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U128::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U1536::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U1536::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U1536::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U1536::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U1536::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U1536::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U1536::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U1792::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U1792::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U1792::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U1792::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U1792::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U1792::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U1792::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U192::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U192::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U192::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U192::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U192::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U192::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U192::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U2048::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U2048::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U2048::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U2048::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U2048::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U2048::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U2048::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U256::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U256::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U256::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U256::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U256::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U3072::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U3072::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U3072::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U3072::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U3072::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U3072::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U3072::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U3584::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U3584::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U3584::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U3584::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U3584::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U3584::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U3584::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U384::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U384::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U384::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U384::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U384::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U384::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U384::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U4096::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U4096::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U4096::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U4096::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U4096::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U4096::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U4096::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U448::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U448::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U448::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U448::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U448::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U448::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U448::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U512::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U512::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U512::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U512::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U512::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U512::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U512::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U576::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U576::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U576::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U576::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U576::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U576::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U576::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U6144::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U6144::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U6144::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U6144::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U6144::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U6144::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U6144::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U64::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U64::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U64::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U64::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U64::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U64::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U64::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U768::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U768::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U768::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U768::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U768::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U768::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U768::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U8192::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U8192::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U8192::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U8192::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U8192::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U8192::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U8192::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U832::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U832::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U832::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U832::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U832::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U832::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U832::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl ArrayEncoding for Uint<crypto_bigint::::uint::U896::{constant#0}>

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U896::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U896::{constant#0}>

Deserialize from a big-endian byte array.

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U896::{constant#0}> as ArrayEncoding>::ByteSize>, ) -> Uint<crypto_bigint::::uint::U896::{constant#0}>

Deserialize from a little-endian byte array.

fn to_be_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U896::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

fn to_le_byte_array( &self, ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U896::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

impl<const LIMBS: usize> AsMut<[Limb]> for Uint<LIMBS>

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

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

impl<const LIMBS: usize> AsMut<[u64; LIMBS]> for Uint<LIMBS>

fn as_mut(&mut self) -> &mut [u64; LIMBS]

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

impl<const LIMBS: usize> AsRef<[Limb]> for Uint<LIMBS>

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

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

impl<const LIMBS: usize> AsRef<[u64; LIMBS]> for Uint<LIMBS>

fn as_ref(&self) -> &[u64; LIMBS]

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

impl<const LIMBS: usize> BitAnd<&Uint<LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAnd<&Uint<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAnd<Uint<LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: Uint<LIMBS>) -> Uint<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAnd for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: Uint<LIMBS>) -> Uint<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAndAssign<&Uint<LIMBS>> for Uint<LIMBS>

fn bitand_assign(&mut self, other: &Uint<LIMBS>)

Performs the &= operation.

impl<const LIMBS: usize> BitAndAssign for Uint<LIMBS>

fn bitand_assign(&mut self, other: Uint<LIMBS>)

Performs the &= operation.

impl<const LIMBS: usize> BitOr<&Uint<LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOr<&Uint<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOr<Uint<LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: Uint<LIMBS>) -> Uint<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOr for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: Uint<LIMBS>) -> Uint<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOrAssign<&Uint<LIMBS>> for Uint<LIMBS>

fn bitor_assign(&mut self, other: &Uint<LIMBS>)

Performs the |= operation.

impl<const LIMBS: usize> BitOrAssign for Uint<LIMBS>

fn bitor_assign(&mut self, other: Uint<LIMBS>)

Performs the |= operation.

impl<const LIMBS: usize> BitXor<&Uint<LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXor<&Uint<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXor<Uint<LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Uint<LIMBS>) -> Uint<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXor for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Uint<LIMBS>) -> Uint<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXorAssign<&Uint<LIMBS>> for Uint<LIMBS>

fn bitxor_assign(&mut self, other: &Uint<LIMBS>)

Performs the ^= operation.

impl<const LIMBS: usize> BitXorAssign for Uint<LIMBS>

fn bitxor_assign(&mut self, other: Uint<LIMBS>)

Performs the ^= operation.

impl<const LIMBS: usize> Bounded for Uint<LIMBS>

const BITS: usize = Self::BITS

Size of this integer in bits.

const BYTES: usize = Self::BYTES

Size of this integer in bytes.

impl<const LIMBS: usize> CheckedAdd<&Uint<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn checked_add(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked subtraction, returning a CtOption which is_some only if the operation did not overflow.

impl<const LIMBS: usize, const HLIMBS: usize> CheckedMul<&Uint<HLIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn checked_mul(&self, rhs: &Uint<HLIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked multiplication, returning a CtOption which is_some only if the operation did not overflow.

impl<const LIMBS: usize> CheckedSub<&Uint<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn checked_sub(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked subtraction, returning a CtOption which is_some only if the operation did not underflow.

impl<const LIMBS: usize> Clone for Uint<LIMBS>

fn clone(&self) -> Uint<LIMBS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#103}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#103}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U2048::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#103}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#103}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#103}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#108}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#108}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U3072::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#108}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#108}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#108}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#113}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#113}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U3584::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#113}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#113}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#113}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#118}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#118}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U4096::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#118}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#118}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#118}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#123}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#123}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U4224::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#123}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#123}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#123}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#128}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#128}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U4352::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#128}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#128}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#128}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#133}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#133}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U6144::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#133}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#133}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#133}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#138}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#138}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U8192::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#138}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#138}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#138}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#143}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#143}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U16384::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#143}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#143}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#143}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#148}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#148}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U192::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#148}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#148}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#148}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#150}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#150}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U192::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#150}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#150}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#150}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#152}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#152}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U256::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#152}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#152}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#152}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#154}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#154}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U256::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#154}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#154}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#154}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#156}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#156}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U320::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#156}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#156}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#156}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#158}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#158}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U320::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#158}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#158}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#158}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#160}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#160}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U320::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#160}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#160}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#160}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#162}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#162}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U320::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#162}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#162}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#162}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#164}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#164}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U384::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#164}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#164}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#164}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#166}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#166}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U384::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#166}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#166}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#166}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#168}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#168}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U384::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#168}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#168}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#168}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#170}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#170}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U384::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#170}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#170}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#170}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#172}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#172}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U448::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#172}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#172}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#172}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#174}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#174}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U448::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#174}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#174}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#174}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#176}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#176}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U448::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#176}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#176}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#176}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#178}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#178}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U448::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#178}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#178}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#178}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#180}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#180}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U448::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#180}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#180}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#180}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#182}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#182}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U448::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#182}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#182}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#182}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#184}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#184}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U512::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#184}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#184}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#184}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#186}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#186}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U512::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#186}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#186}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#186}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#188}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#188}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U512::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#188}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#188}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#188}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#190}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#190}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U512::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#190}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#190}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#190}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#192}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#192}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U512::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#192}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#192}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#192}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#194}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#194}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U512::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#194}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#194}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#194}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#196}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#196}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U576::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#196}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#196}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#196}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#198}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#198}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U576::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#198}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#198}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#198}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#200}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#200}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U576::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#200}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#200}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#200}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#202}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#202}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U576::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#202}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#202}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#202}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#204}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#204}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U576::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#204}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#204}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#204}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#206}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#206}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U576::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#206}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#206}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#206}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#208}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#208}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U576::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#208}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#208}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#208}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#210}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#210}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U576::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#210}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#210}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#210}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#212}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#212}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#212}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#212}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#212}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#214}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#214}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#214}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#214}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#214}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#216}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#216}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#216}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#216}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#216}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#218}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#218}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#218}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#218}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#218}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#220}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#220}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#220}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#220}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#220}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#222}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#222}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#222}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#222}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#222}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#224}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#224}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#224}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#224}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#224}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#226}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#226}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#226}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#226}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#226}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#228}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#228}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#228}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#228}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#228}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#230}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#230}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#230}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#230}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#230}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#232}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#232}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#232}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#232}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#232}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#234}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#234}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#234}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#234}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#234}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#236}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#236}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#236}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#236}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#236}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#238}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#238}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#238}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#238}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#238}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#240}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#240}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#240}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#240}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#240}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#242}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#242}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#242}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#242}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#242}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#244}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#244}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#244}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#244}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#244}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#246}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#246}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U704::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#246}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#246}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#246}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#248}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#248}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#248}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#248}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#248}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#250}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#250}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#250}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#250}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#250}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#252}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#252}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#252}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#252}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#252}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#254}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#254}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#254}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#254}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#254}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#256}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#256}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#256}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#256}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#256}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#258}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#258}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#258}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#258}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#258}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#260}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#260}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#260}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#260}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#260}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#262}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#262}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#262}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#262}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#262}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#264}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#264}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#264}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#264}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#264}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#266}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#266}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#266}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#266}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#266}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#268}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#268}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#268}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#268}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#268}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#270}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#270}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#270}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#270}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#270}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#272}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#272}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#272}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#272}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#272}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#274}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#274}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#274}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#274}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#274}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#276}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#276}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#276}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#276}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#276}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#278}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#278}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#278}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#278}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#278}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#280}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#280}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#280}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#280}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#280}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#282}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#282}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#282}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#282}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#282}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#284}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#284}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#284}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#284}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#284}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#286}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#286}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#286}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#286}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#286}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#288}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#288}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#288}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#288}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#288}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#290}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#290}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U832::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#290}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#290}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#290}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#292}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#292}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#292}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#292}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#292}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#294}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#294}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#294}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#294}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#294}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#296}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#296}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#296}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#296}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#296}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#298}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#298}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#298}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#298}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#298}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#300}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#300}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#300}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#300}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#300}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#302}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#302}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#302}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#302}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#302}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#304}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#304}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#304}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#304}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#304}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#306}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#306}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#306}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#306}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#306}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#308}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#308}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#308}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#308}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#308}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#310}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#310}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#310}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#310}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#310}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#312}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#312}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#312}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#312}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#312}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#314}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#314}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#314}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#314}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#314}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#316}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#316}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#316}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#316}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#316}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#318}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#318}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#318}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#318}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#318}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#320}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#320}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#320}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#320}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#320}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#322}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#322}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#322}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#322}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#322}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#324}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#324}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#324}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#324}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#324}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#326}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#326}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#326}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#326}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#326}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#328}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#328}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#328}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#328}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#328}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#330}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#330}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#330}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#330}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#330}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#332}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#332}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#332}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#332}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#332}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#334}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#334}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#334}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#334}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#334}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#336}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#336}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#336}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#336}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#336}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#338}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#338}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#338}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#338}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#338}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#340}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#340}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#340}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#340}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#340}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#342}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#342}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U960::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#342}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#342}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#342}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#344}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#344}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#344}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#344}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#344}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#346}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#346}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#346}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#346}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#346}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#348}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#348}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#348}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#348}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#348}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#350}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#350}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#350}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#350}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#350}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#352}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#352}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#352}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#352}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#352}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#354}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#354}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#354}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#354}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#354}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#356}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#356}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#356}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#356}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#356}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#358}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#358}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#358}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#358}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#358}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#360}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#360}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#360}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#360}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#360}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#362}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#362}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#362}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#362}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#362}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#364}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#364}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#364}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#364}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#364}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#366}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#366}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#366}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#366}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#366}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#368}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#368}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#368}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#368}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#368}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#370}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#370}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#370}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#370}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#370}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#48}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#48}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U128::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#48}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#48}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#48}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#53}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#53}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U256::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#53}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#53}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#53}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#58}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#58}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U384::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#58}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#58}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#58}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#63}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#63}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U512::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#63}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#63}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#63}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#68}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#68}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U640::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#68}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#68}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#68}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#73}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#73}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U768::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#73}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#73}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#73}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#78}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#78}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U896::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#78}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#78}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#78}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#83}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#83}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1024::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#83}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#83}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#83}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#88}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#88}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1280::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#88}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#88}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#88}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#93}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#93}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1536::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#93}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#93}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#93}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#98}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#98}::{constant#1}>

type MixedOutput = Uint<crypto_bigint::::uint::U1792::{constant#0}>

Concatenated output: combination of Lo and Self.

fn concat_mixed( &self, lo: &Uint<crypto_bigint::::uint::{impl#98}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#98}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#98}::{constant#0}>>>::MixedOutput

Concatenate the two values, with self as most significant and lo as the least significant.

impl<const LIMBS: usize> ConditionallySelectable for Uint<LIMBS>

fn conditional_select( a: &Uint<LIMBS>, b: &Uint<LIMBS>, choice: Choice, ) -> Uint<LIMBS>

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl<const LIMBS: usize> ConstantTimeEq for Uint<LIMBS>

fn ct_eq(&self, other: &Uint<LIMBS>) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<const LIMBS: usize> ConstantTimeGreater for Uint<LIMBS>

fn ct_gt(&self, other: &Uint<LIMBS>) -> Choice

Determine whether self > other.

impl<const LIMBS: usize> ConstantTimeLess for Uint<LIMBS>

fn ct_lt(&self, other: &Uint<LIMBS>) -> Choice

Determine whether self < other.

impl<const LIMBS: usize> Debug for Uint<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> Default for Uint<LIMBS>

fn default() -> Uint<LIMBS>

Returns the “default value” for a type.

impl<const LIMBS: usize> Display for Uint<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> Div<&NonZero<Limb>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div( self, rhs: &NonZero<Limb>, ) -> <&Uint<LIMBS> as Div<&NonZero<Limb>>>::Output

Performs the / operation.

impl<const LIMBS: usize> Div<&NonZero<Limb>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div( self, rhs: &NonZero<Limb>, ) -> <Uint<LIMBS> as Div<&NonZero<Limb>>>::Output

Performs the / operation.

impl<const LIMBS: usize> Div<&NonZero<Uint<LIMBS>>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div( self, rhs: &NonZero<Uint<LIMBS>>, ) -> <&Uint<LIMBS> as Div<&NonZero<Uint<LIMBS>>>>::Output

Performs the / operation.

impl<const LIMBS: usize> Div<&NonZero<Uint<LIMBS>>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div( self, rhs: &NonZero<Uint<LIMBS>>, ) -> <Uint<LIMBS> as Div<&NonZero<Uint<LIMBS>>>>::Output

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<Limb>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Limb>) -> <&Uint<LIMBS> as Div<NonZero<Limb>>>::Output

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<Limb>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Limb>) -> <Uint<LIMBS> as Div<NonZero<Limb>>>::Output

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<Uint<LIMBS>>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div( self, rhs: NonZero<Uint<LIMBS>>, ) -> <&Uint<LIMBS> as Div<NonZero<Uint<LIMBS>>>>::Output

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<Uint<LIMBS>>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div( self, rhs: NonZero<Uint<LIMBS>>, ) -> <Uint<LIMBS> as Div<NonZero<Uint<LIMBS>>>>::Output

Performs the / operation.

impl<const LIMBS: usize> DivAssign<&NonZero<Limb>> for Uint<LIMBS>

fn div_assign(&mut self, rhs: &NonZero<Limb>)

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<&NonZero<Uint<LIMBS>>> for Uint<LIMBS>

fn div_assign(&mut self, rhs: &NonZero<Uint<LIMBS>>)

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<NonZero<Limb>> for Uint<LIMBS>

fn div_assign(&mut self, rhs: NonZero<Limb>)

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<NonZero<Uint<LIMBS>>> for Uint<LIMBS>

fn div_assign(&mut self, rhs: NonZero<Uint<LIMBS>>)

Performs the /= operation.

impl Encoding for Uint<crypto_bigint::::uint::U1024::{constant#0}>

type Repr = [u8; 128]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U1024::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U1024::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U1024::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U1024::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U1024::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U1024::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U1280::{constant#0}>

type Repr = [u8; 160]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U1280::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U1280::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U1280::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U1280::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U1280::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U1280::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U128::{constant#0}>

type Repr = [u8; 16]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U128::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U128::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U128::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U128::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U128::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U128::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U1536::{constant#0}>

type Repr = [u8; 192]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U1536::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U1536::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U1536::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U1536::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U1536::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U1536::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U16384::{constant#0}>

type Repr = [u8; 2048]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U16384::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U16384::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U16384::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U16384::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U16384::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U16384::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U1792::{constant#0}>

type Repr = [u8; 224]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U1792::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U1792::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U1792::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U1792::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U1792::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U1792::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U192::{constant#0}>

type Repr = [u8; 24]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U192::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U192::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U192::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U192::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U192::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U192::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U2048::{constant#0}>

type Repr = [u8; 256]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U2048::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U2048::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U2048::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U2048::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U2048::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U2048::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U256::{constant#0}>

type Repr = [u8; 32]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U256::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U256::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U256::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U256::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U3072::{constant#0}>

type Repr = [u8; 384]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U3072::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U3072::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U3072::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U3072::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U3072::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U3072::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U320::{constant#0}>

type Repr = [u8; 40]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U320::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U320::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U320::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U320::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U320::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U320::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U32768::{constant#0}>

type Repr = [u8; 4096]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U32768::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U32768::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U32768::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U32768::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U32768::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U32768::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U3584::{constant#0}>

type Repr = [u8; 448]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U3584::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U3584::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U3584::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U3584::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U3584::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U3584::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U384::{constant#0}>

type Repr = [u8; 48]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U384::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U384::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U384::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U384::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U384::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U384::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U4096::{constant#0}>

type Repr = [u8; 512]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U4096::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U4096::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U4096::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U4096::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U4096::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U4096::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U4224::{constant#0}>

type Repr = [u8; 528]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U4224::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U4224::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U4224::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U4224::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U4224::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U4224::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U4352::{constant#0}>

type Repr = [u8; 544]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U4352::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U4352::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U4352::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U4352::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U4352::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U4352::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U448::{constant#0}>

type Repr = [u8; 56]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U448::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U448::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U448::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U448::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U448::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U448::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U512::{constant#0}>

type Repr = [u8; 64]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U512::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U512::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U512::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U512::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U512::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U512::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U576::{constant#0}>

type Repr = [u8; 72]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U576::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U576::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U576::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U576::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U576::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U576::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U6144::{constant#0}>

type Repr = [u8; 768]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U6144::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U6144::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U6144::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U6144::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U6144::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U6144::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U640::{constant#0}>

type Repr = [u8; 80]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U640::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U640::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U640::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U640::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U640::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U640::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U64::{constant#0}>

type Repr = [u8; 8]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U64::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U64::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U64::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U64::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U64::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U64::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U704::{constant#0}>

type Repr = [u8; 88]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U704::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U704::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U704::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U704::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U704::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U704::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U768::{constant#0}>

type Repr = [u8; 96]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U768::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U768::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U768::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U768::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U768::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U768::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U8192::{constant#0}>

type Repr = [u8; 1024]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U8192::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U8192::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U8192::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U8192::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U8192::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U8192::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U832::{constant#0}>

type Repr = [u8; 104]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U832::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U832::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U832::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U832::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U832::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U832::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U896::{constant#0}>

type Repr = [u8; 112]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U896::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U896::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U896::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U896::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U896::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U896::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl Encoding for Uint<crypto_bigint::::uint::U960::{constant#0}>

type Repr = [u8; 120]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U960::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U960::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U960::{constant#0}> as Encoding>::Repr, ) -> Uint<crypto_bigint::::uint::U960::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U960::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self, ) -> <Uint<crypto_bigint::::uint::U960::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

impl FieldBytesEncoding<NistP256> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn decode_field_bytes( field_bytes: &GenericArray<u8, <NistP256 as Curve>::FieldBytesSize>, ) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Decode unsigned integer from serialized field element.

fn encode_field_bytes( &self, ) -> GenericArray<u8, <NistP256 as Curve>::FieldBytesSize>

Encode unsigned integer into serialized field element.

impl FieldBytesEncoding<Secp256k1> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn decode_field_bytes( field_bytes: &GenericArray<u8, <Secp256k1 as Curve>::FieldBytesSize>, ) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Decode unsigned integer from serialized field element.

fn encode_field_bytes( &self, ) -> GenericArray<u8, <Secp256k1 as Curve>::FieldBytesSize>

Encode unsigned integer into serialized field element.

impl<const L: usize, const H: usize, const LIMBS: usize> From<&(Uint<L>, Uint<H>)> for Uint<LIMBS>

where Uint<H>: ConcatMixed<Uint<L>, MixedOutput = Uint<LIMBS>>,

fn from(nums: &(Uint<L>, Uint<H>)) -> Uint<LIMBS>

Converts to this type from the input type.

impl From<&Scalar> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn from(scalar: &Scalar) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Converts to this type from the input type.

impl From<&Scalar> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn from(scalar: &Scalar) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Converts to this type from the input type.

impl<const LIMBS: usize, const LIMBS2: usize> From<&Uint<LIMBS>> for Uint<LIMBS2>

fn from(num: &Uint<LIMBS>) -> Uint<LIMBS2>

Converts to this type from the input type.

impl<const LIMBS: usize> From<[Limb; LIMBS]> for Uint<LIMBS>

fn from(limbs: [Limb; LIMBS]) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const LIMBS: usize> From<[u64; LIMBS]> for Uint<LIMBS>

fn from(arr: [u64; LIMBS]) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const L: usize, const H: usize, const LIMBS: usize> From<(Uint<L>, Uint<H>)> for Uint<LIMBS>

where Uint<H>: ConcatMixed<Uint<L>, MixedOutput = Uint<LIMBS>>,

fn from(nums: (Uint<L>, Uint<H>)) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const LIMBS: usize> From<Limb> for Uint<LIMBS>

fn from(limb: Limb) -> Uint<LIMBS>

Converts to this type from the input type.

impl From<Scalar> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn from(scalar: Scalar) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Converts to this type from the input type.

impl From<Scalar> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn from(scalar: Scalar) -> Uint<crypto_bigint::::uint::U256::{constant#0}>

Converts to this type from the input type.

impl<const LIMBS: usize> From<u128> for Uint<LIMBS>

fn from(n: u128) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const LIMBS: usize> From<u16> for Uint<LIMBS>

fn from(n: u16) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const LIMBS: usize> From<u32> for Uint<LIMBS>

fn from(n: u32) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const LIMBS: usize> From<u64> for Uint<LIMBS>

fn from(n: u64) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const LIMBS: usize> From<u8> for Uint<LIMBS>

fn from(n: u8) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const LIMBS: usize> Hash for Uint<LIMBS>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const LIMBS: usize> Integer for Uint<LIMBS>

const ONE: Uint<LIMBS> = Self::ONE

The value 1.

const MAX: Uint<LIMBS> = Self::MAX

Maximum value this integer can express.

const BITS: usize = Self::BITS

Total size of the represented integer in bits.

const BYTES: usize = Self::BYTES

Total size of the represented integer in bytes.

const LIMBS: usize = Self::LIMBS

The number of limbs used on this platform.

fn is_odd(&self) -> Choice

Is this integer value an odd number?

fn is_even(&self) -> Choice

Is this integer value an even number?

impl<const LIMBS: usize> LowerHex for Uint<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize, const HLIMBS: usize> Mul<&Uint<HLIMBS>> for &Uint<LIMBS>

where Uint<HLIMBS>: ConcatMixed<Uint<LIMBS>>,

type Output = <Uint<HLIMBS> as ConcatMixed<Uint<LIMBS>>>::MixedOutput

The resulting type after applying the * operator.

fn mul( self, other: &Uint<HLIMBS>, ) -> <&Uint<LIMBS> as Mul<&Uint<HLIMBS>>>::Output

Performs the * operation.

impl<const LIMBS: usize, const HLIMBS: usize> Mul<&Uint<HLIMBS>> for Uint<LIMBS>

where Uint<HLIMBS>: ConcatMixed<Uint<LIMBS>>,

type Output = <Uint<HLIMBS> as ConcatMixed<Uint<LIMBS>>>::MixedOutput

The resulting type after applying the * operator.

fn mul( self, other: &Uint<HLIMBS>, ) -> <Uint<LIMBS> as Mul<&Uint<HLIMBS>>>::Output

Performs the * operation.

impl<const LIMBS: usize, const HLIMBS: usize> Mul<Uint<HLIMBS>> for &Uint<LIMBS>

where Uint<HLIMBS>: ConcatMixed<Uint<LIMBS>>,

type Output = <Uint<HLIMBS> as ConcatMixed<Uint<LIMBS>>>::MixedOutput

The resulting type after applying the * operator.

fn mul(self, other: Uint<HLIMBS>) -> <&Uint<LIMBS> as Mul<Uint<HLIMBS>>>::Output

Performs the * operation.

impl<const LIMBS: usize, const HLIMBS: usize> Mul<Uint<HLIMBS>> for Uint<LIMBS>

where Uint<HLIMBS>: ConcatMixed<Uint<LIMBS>>,

type Output = <Uint<HLIMBS> as ConcatMixed<Uint<LIMBS>>>::MixedOutput

The resulting type after applying the * operator.

fn mul(self, other: Uint<HLIMBS>) -> <Uint<LIMBS> as Mul<Uint<HLIMBS>>>::Output

Performs the * operation.

impl<const N: usize, const LIMBS: usize, const RHS_LIMBS: usize> MultiExponentiateBoundedExp<Uint<RHS_LIMBS>, [(DynResidue<LIMBS>, Uint<RHS_LIMBS>); N]> for DynResidue<LIMBS>

fn multi_exponentiate_bounded_exp( bases_and_exponents: &[(DynResidue<LIMBS>, Uint<RHS_LIMBS>); N], exponent_bits: usize, ) -> DynResidue<LIMBS>

Calculates x1 ^ k1 * ... * xn ^ kn.

impl<const N: usize, MOD, const LIMBS: usize, const RHS_LIMBS: usize> MultiExponentiateBoundedExp<Uint<RHS_LIMBS>, [(Residue<MOD, LIMBS>, Uint<RHS_LIMBS>); N]> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn multi_exponentiate_bounded_exp( bases_and_exponents: &[(Residue<MOD, LIMBS>, Uint<RHS_LIMBS>); N], exponent_bits: usize, ) -> Residue<MOD, LIMBS>

Calculates x1 ^ k1 * ... * xn ^ kn.

impl<const LIMBS: usize> NegMod for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn neg_mod(&self, p: &Uint<LIMBS>) -> Uint<LIMBS>

Compute -self mod p.

impl<const LIMBS: usize> Not for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the ! operator.

fn not(self) -> <Uint<LIMBS> as Not>::Output

Performs the unary ! operation.

impl<const LIMBS: usize> Ord for Uint<LIMBS>

fn cmp(&self, other: &Uint<LIMBS>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<const LIMBS: usize> PartialEq for Uint<LIMBS>

fn eq(&self, other: &Uint<LIMBS>) -> bool

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const LIMBS: usize> PartialOrd for Uint<LIMBS>

fn partial_cmp(&self, other: &Uint<LIMBS>) -> 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.

impl<const LIMBS: usize, const RHS_LIMBS: usize> PowBoundedExp<Uint<RHS_LIMBS>> for DynResidue<LIMBS>

fn pow_bounded_exp( &self, exponent: &Uint<RHS_LIMBS>, exponent_bits: usize, ) -> DynResidue<LIMBS>

Raises to the exponent power, with exponent_bits representing the number of (least significant) bits to take into account for the exponent.

impl<MOD, const LIMBS: usize, const RHS_LIMBS: usize> PowBoundedExp<Uint<RHS_LIMBS>> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn pow_bounded_exp( &self, exponent: &Uint<RHS_LIMBS>, exponent_bits: usize, ) -> Residue<MOD, LIMBS>

Raises to the exponent power, with exponent_bits representing the number of (least significant) bits to take into account for the exponent.

impl<const LIMBS: usize> Random for Uint<LIMBS>

fn random(rng: &mut impl CryptoRngCore) -> Uint<LIMBS>

Generate a cryptographically secure random Uint.

impl<const LIMBS: usize> RandomMod for Uint<LIMBS>

fn random_mod( rng: &mut impl CryptoRngCore, modulus: &NonZero<Uint<LIMBS>>, ) -> Uint<LIMBS>

Generate a cryptographically secure random Uint which is less than a given modulus.

This function uses rejection sampling, a method which produces an unbiased distribution of in-range values provided the underlying CSRNG is unbiased, but runs in variable-time.

The variable-time nature of the algorithm should not pose a security issue so long as the underlying random number generator is truly a CSRNG, where previous outputs are unrelated to subsequent outputs and do not reveal information about the RNG’s internal state.

impl Reduce<Uint<crypto_bigint::::uint::U256::{constant#0}>> for Scalar

type Bytes = GenericArray<u8, <Secp256k1 as Curve>::FieldBytesSize>

Bytes used as input to Reduce::reduce_bytes.

fn reduce(w: Uint<crypto_bigint::::uint::U256::{constant#0}>) -> Scalar

Perform a modular reduction, returning a field element.

fn reduce_bytes( bytes: &GenericArray<u8, <Secp256k1 as Curve>::FieldBytesSize>, ) -> Scalar

Interpret the given bytes as an integer and perform a modular reduction.

impl Reduce<Uint<crypto_bigint::::uint::U256::{constant#0}>> for Scalar

type Bytes = GenericArray<u8, <NistP256 as Curve>::FieldBytesSize>

Bytes used as input to Reduce::reduce_bytes.

fn reduce(w: Uint<crypto_bigint::::uint::U256::{constant#0}>) -> Scalar

Perform a modular reduction, returning a field element.

fn reduce_bytes( bytes: &GenericArray<u8, <NistP256 as Curve>::FieldBytesSize>, ) -> Scalar

Interpret the given bytes as an integer and perform a modular reduction.

impl Reduce<Uint<crypto_bigint::::uint::U512::{constant#0}>> for Scalar

type Bytes = GenericArray<u8, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>

Bytes used as input to Reduce::reduce_bytes.

fn reduce(w: Uint<crypto_bigint::::uint::U512::{constant#0}>) -> Scalar

Perform a modular reduction, returning a field element.

fn reduce_bytes( bytes: &GenericArray<u8, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>, ) -> Scalar

Interpret the given bytes as an integer and perform a modular reduction.

impl ReduceNonZero<Uint<crypto_bigint::::uint::U256::{constant#0}>> for Scalar

fn reduce_nonzero(w: Uint<crypto_bigint::::uint::U256::{constant#0}>) -> Scalar

Perform a modular reduction, returning a field element.

fn reduce_nonzero_bytes( bytes: &GenericArray<u8, <Secp256k1 as Curve>::FieldBytesSize>, ) -> Scalar

Interpret the given bytes as an integer and perform a modular reduction to a non-zero output.

impl ReduceNonZero<Uint<crypto_bigint::::uint::U256::{constant#0}>> for Scalar

fn reduce_nonzero(w: Uint<crypto_bigint::::uint::U256::{constant#0}>) -> Scalar

Perform a modular reduction, returning a field element.

fn reduce_nonzero_bytes( bytes: &GenericArray<u8, <NistP256 as Curve>::FieldBytesSize>, ) -> Scalar

Interpret the given bytes as an integer and perform a modular reduction to a non-zero output.

impl ReduceNonZero<Uint<crypto_bigint::::uint::U512::{constant#0}>> for Scalar

fn reduce_nonzero(w: Uint<crypto_bigint::::uint::U512::{constant#0}>) -> Scalar

Perform a modular reduction, returning a field element.

fn reduce_nonzero_bytes( bytes: &GenericArray<u8, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>, ) -> Scalar

Interpret the given bytes as an integer and perform a modular reduction to a non-zero output.

impl<const LIMBS: usize> Rem<&NonZero<Limb>> for &Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

fn rem( self, rhs: &NonZero<Limb>, ) -> <&Uint<LIMBS> as Rem<&NonZero<Limb>>>::Output

Performs the % operation.

impl<const LIMBS: usize> Rem<&NonZero<Limb>> for Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

fn rem( self, rhs: &NonZero<Limb>, ) -> <Uint<LIMBS> as Rem<&NonZero<Limb>>>::Output

Performs the % operation.

impl<const LIMBS: usize> Rem<&NonZero<Uint<LIMBS>>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the % operator.

fn rem( self, rhs: &NonZero<Uint<LIMBS>>, ) -> <&Uint<LIMBS> as Rem<&NonZero<Uint<LIMBS>>>>::Output

Performs the % operation.

impl<const LIMBS: usize> Rem<&NonZero<Uint<LIMBS>>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the % operator.

fn rem( self, rhs: &NonZero<Uint<LIMBS>>, ) -> <Uint<LIMBS> as Rem<&NonZero<Uint<LIMBS>>>>::Output

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<Limb>> for &Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Limb>) -> <&Uint<LIMBS> as Rem<NonZero<Limb>>>::Output

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<Limb>> for Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Limb>) -> <Uint<LIMBS> as Rem<NonZero<Limb>>>::Output

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<Uint<LIMBS>>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the % operator.

fn rem( self, rhs: NonZero<Uint<LIMBS>>, ) -> <&Uint<LIMBS> as Rem<NonZero<Uint<LIMBS>>>>::Output

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<Uint<LIMBS>>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the % operator.

fn rem( self, rhs: NonZero<Uint<LIMBS>>, ) -> <Uint<LIMBS> as Rem<NonZero<Uint<LIMBS>>>>::Output

Performs the % operation.

impl<const LIMBS: usize> RemAssign<&NonZero<Limb>> for Uint<LIMBS>

fn rem_assign(&mut self, rhs: &NonZero<Limb>)

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<&NonZero<Uint<LIMBS>>> for Uint<LIMBS>

fn rem_assign(&mut self, rhs: &NonZero<Uint<LIMBS>>)

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<NonZero<Limb>> for Uint<LIMBS>

fn rem_assign(&mut self, rhs: NonZero<Limb>)

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<NonZero<Uint<LIMBS>>> for Uint<LIMBS>

fn rem_assign(&mut self, rhs: NonZero<Uint<LIMBS>>)

Performs the %= operation.

impl<const LIMBS: usize> Shl<usize> for &Uint<LIMBS>

fn shl(self, rhs: usize) -> Uint<LIMBS>

NOTE: this operation is variable time with respect to rhs ONLY.

When used with a fixed rhs, this function is constant-time with respect to self.

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

impl<const LIMBS: usize> Shl<usize> for Uint<LIMBS>

fn shl(self, rhs: usize) -> Uint<LIMBS>

NOTE: this operation is variable time with respect to rhs ONLY.

When used with a fixed rhs, this function is constant-time with respect to self.

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

impl<const LIMBS: usize> ShlAssign<usize> for Uint<LIMBS>

fn shl_assign(&mut self, rhs: usize)

NOTE: this operation is variable time with respect to rhs ONLY.

When used with a fixed rhs, this function is constant-time with respect to self.

impl<const LIMBS: usize> Shr<usize> for &Uint<LIMBS>

fn shr(self, rhs: usize) -> Uint<LIMBS>

NOTE: this operation is variable time with respect to rhs ONLY.

When used with a fixed rhs, this function is constant-time with respect to self.

type Output = Uint<LIMBS>

The resulting type after applying the >> operator.

impl<const LIMBS: usize> Shr<usize> for Uint<LIMBS>

fn shr(self, rhs: usize) -> Uint<LIMBS>

NOTE: this operation is variable time with respect to rhs ONLY.

When used with a fixed rhs, this function is constant-time with respect to self.

type Output = Uint<LIMBS>

The resulting type after applying the >> operator.

impl<const LIMBS: usize> ShrAssign<usize> for Uint<LIMBS>

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl Split for Uint<crypto_bigint::::uint::U1024::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#86}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U1280::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#91}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U128::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#51}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U1536::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#96}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U16384::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#146}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U1792::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#101}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U2048::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#106}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U256::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#56}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U3072::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#111}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U3584::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#116}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U384::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#61}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U4096::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#121}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U4224::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#126}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U4352::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#131}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U512::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#66}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U6144::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#136}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U640::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#71}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U768::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#76}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U8192::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#141}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl Split for Uint<crypto_bigint::::uint::U896::{constant#0}>

type Output = Uint<crypto_bigint::::uint::{impl#81}::Output::{constant#0}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#100}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#100}::{constant#1}>> for Uint<crypto_bigint::::uint::U1792::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#100}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#100}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#105}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#105}::{constant#1}>> for Uint<crypto_bigint::::uint::U2048::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#105}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#105}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#110}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#110}::{constant#1}>> for Uint<crypto_bigint::::uint::U3072::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#110}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#110}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#115}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#115}::{constant#1}>> for Uint<crypto_bigint::::uint::U3584::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#115}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#115}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#120}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#120}::{constant#1}>> for Uint<crypto_bigint::::uint::U4096::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#120}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#120}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#125}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#125}::{constant#1}>> for Uint<crypto_bigint::::uint::U4224::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#125}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#125}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#130}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#130}::{constant#1}>> for Uint<crypto_bigint::::uint::U4352::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#130}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#130}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#135}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#135}::{constant#1}>> for Uint<crypto_bigint::::uint::U6144::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#135}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#135}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#140}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#140}::{constant#1}>> for Uint<crypto_bigint::::uint::U8192::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#140}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#140}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#145}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#145}::{constant#1}>> for Uint<crypto_bigint::::uint::U16384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#145}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#145}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#149}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#149}::{constant#1}>> for Uint<crypto_bigint::::uint::U192::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#149}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#149}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#151}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#151}::{constant#1}>> for Uint<crypto_bigint::::uint::U192::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#151}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#151}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#153}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#153}::{constant#1}>> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#153}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#153}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#155}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#155}::{constant#1}>> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#155}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#155}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#157}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#157}::{constant#1}>> for Uint<crypto_bigint::::uint::U320::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#157}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#157}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#159}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#159}::{constant#1}>> for Uint<crypto_bigint::::uint::U320::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#159}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#159}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#161}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#161}::{constant#1}>> for Uint<crypto_bigint::::uint::U320::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#161}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#161}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#163}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#163}::{constant#1}>> for Uint<crypto_bigint::::uint::U320::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#163}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#163}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#165}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#165}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#165}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#165}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#167}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#167}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#167}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#167}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#169}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#169}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#169}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#169}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#171}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#171}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#171}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#171}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#173}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#173}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#173}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#173}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#175}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#175}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#175}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#175}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#177}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#177}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#177}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#177}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#179}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#179}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#179}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#179}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#181}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#181}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#181}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#181}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#183}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#183}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#183}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#183}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#185}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#185}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#185}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#185}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#187}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#187}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#187}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#187}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#189}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#189}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#189}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#189}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#191}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#191}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#191}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#191}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#193}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#193}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#193}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#193}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#195}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#195}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#195}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#195}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#197}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#197}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#197}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#197}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#199}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#199}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#199}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#199}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#201}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#201}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#201}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#201}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#203}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#203}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#203}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#203}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#205}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#205}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#205}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#205}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#207}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#207}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#207}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#207}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#209}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#209}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#209}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#209}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#211}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#211}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#211}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#211}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#213}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#213}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#213}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#213}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#215}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#215}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#215}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#215}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#217}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#217}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#217}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#217}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#219}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#219}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#219}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#219}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#221}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#221}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#221}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#221}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#223}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#223}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#223}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#223}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#225}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#225}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#225}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#225}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#227}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#227}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#227}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#227}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#229}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#229}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#229}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#229}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#231}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#231}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#231}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#231}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#233}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#233}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#233}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#233}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#235}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#235}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#235}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#235}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#237}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#237}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#237}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#237}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#239}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#239}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#239}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#239}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#241}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#241}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#241}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#241}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#243}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#243}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#243}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#243}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#245}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#245}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#245}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#245}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#247}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#247}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#247}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#247}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#249}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#249}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#249}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#249}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#251}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#251}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#251}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#251}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#253}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#253}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#253}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#253}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#255}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#255}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#255}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#255}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#257}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#257}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#257}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#257}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#259}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#259}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#259}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#259}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#261}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#261}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#261}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#261}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#263}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#263}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#263}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#263}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#265}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#265}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#265}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#265}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#267}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#267}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#267}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#267}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#269}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#269}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#269}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#269}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#271}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#271}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#271}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#271}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#273}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#273}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#273}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#273}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#275}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#275}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#275}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#275}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#277}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#277}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#277}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#277}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#279}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#279}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#279}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#279}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#281}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#281}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#281}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#281}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#283}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#283}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#283}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#283}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#285}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#285}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#285}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#285}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#287}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#287}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#287}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#287}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#289}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#289}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#289}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#289}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#291}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#291}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#291}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#291}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#293}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#293}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#293}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#293}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#295}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#295}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#295}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#295}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#297}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#297}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#297}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#297}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#299}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#299}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#299}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#299}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#301}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#301}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#301}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#301}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#303}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#303}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#303}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#303}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#305}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#305}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#305}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#305}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#307}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#307}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#307}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#307}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#309}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#309}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#309}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#309}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#311}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#311}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#311}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#311}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#313}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#313}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#313}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#313}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#315}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#315}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#315}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#315}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#317}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#317}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#317}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#317}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#319}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#319}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#319}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#319}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#321}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#321}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#321}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#321}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#323}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#323}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#323}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#323}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#325}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#325}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#325}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#325}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#327}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#327}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#327}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#327}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#329}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#329}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#329}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#329}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#331}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#331}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#331}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#331}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#333}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#333}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#333}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#333}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#335}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#335}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#335}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#335}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#337}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#337}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#337}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#337}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#339}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#339}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#339}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#339}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#341}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#341}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#341}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#341}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#343}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#343}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#343}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#343}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#345}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#345}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#345}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#345}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#347}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#347}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#347}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#347}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#349}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#349}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#349}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#349}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#351}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#351}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#351}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#351}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#353}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#353}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#353}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#353}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#355}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#355}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#355}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#355}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#357}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#357}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#357}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#357}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#359}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#359}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#359}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#359}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#361}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#361}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#361}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#361}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#363}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#363}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#363}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#363}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#365}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#365}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#365}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#365}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#367}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#367}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#367}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#367}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#369}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#369}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#369}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#369}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#371}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#371}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#371}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#371}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#50}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#50}::{constant#1}>> for Uint<crypto_bigint::::uint::U128::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#50}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#50}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#55}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#55}::{constant#1}>> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#55}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#55}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#60}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#60}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#60}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#60}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#65}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#65}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#65}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#65}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#70}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#70}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#70}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#70}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#75}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#75}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#75}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#75}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#80}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#80}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#80}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#80}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#85}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#85}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#85}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#85}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#90}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#90}::{constant#1}>> for Uint<crypto_bigint::::uint::U1280::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#90}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#90}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#95}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#95}::{constant#1}>> for Uint<crypto_bigint::::uint::U1536::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#95}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#95}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl<const LIMBS: usize> SubMod for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn sub_mod(&self, rhs: &Uint<LIMBS>, p: &Uint<LIMBS>) -> Uint<LIMBS>

Compute self - rhs mod p.

impl<const LIMBS: usize> UpperHex for Uint<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> Zero for Uint<LIMBS>

const ZERO: Uint<LIMBS> = Self::ZERO

The value 0.

fn is_zero(&self) -> Choice

Determine if this value is equal to zero.

impl<const LIMBS: usize> Copy for Uint<LIMBS>

impl<const LIMBS: usize> DefaultIsZeroes for Uint<LIMBS>

Available on crate feature zeroize only.

impl<const LIMBS: usize> Eq for Uint<LIMBS>