Type Alias U256

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

256-bit unsigned big integer.

Aliased Type

struct U256 { /* private fields */ }

Implementations

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<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 Uint<crypto_bigint::::uint::{impl#103}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#103}::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::{impl#108}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#108}::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::{impl#113}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#113}::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::{impl#118}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#118}::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::{impl#123}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#123}::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::{impl#128}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#128}::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::{impl#133}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#133}::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::{impl#138}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#138}::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::{impl#143}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#143}::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::{impl#48}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#48}::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::{impl#53}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#53}::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::{impl#58}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#58}::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::{impl#63}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#63}::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::{impl#68}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#68}::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::{impl#73}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#73}::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::{impl#78}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#78}::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::{impl#83}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#83}::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::{impl#88}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#88}::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::{impl#93}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#93}::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::{impl#98}::{constant#0}>

pub const fn concat( &self, lo: &Uint<crypto_bigint::::uint::{impl#98}::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::U1024::{constant#0}>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Trait Implementations

impl FieldBytesEncoding<NistP256> for U256

fn decode_field_bytes(field_bytes: &FieldBytes) -> Self

Decode unsigned integer from serialized field element.

fn encode_field_bytes(&self) -> FieldBytes

Encode unsigned integer into serialized field element.

impl From<&Scalar> for U256

fn from(scalar: &Scalar) -> U256

Converts to this type from the input type.

impl From<Scalar> for U256

fn from(scalar: Scalar) -> U256

Converts to this type from the input type.

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 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 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 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 copy of the value.

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

Performs copy-assignment from source.

impl ConcatMixed<Uint<crypto_bigint::::uint::{impl#102}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#102}::{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#102}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#102}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#102}::{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#107}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#107}::{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#107}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#107}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#107}::{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#112}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#112}::{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#112}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#112}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#112}::{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#117}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#117}::{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#117}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#117}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#117}::{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#122}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#122}::{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#122}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#122}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#122}::{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#127}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#127}::{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#127}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#127}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#127}::{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#132}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#132}::{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#132}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#132}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#132}::{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#137}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#137}::{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#137}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#137}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#137}::{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#142}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#142}::{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#142}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#142}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#142}::{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#147}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#147}::{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#147}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#147}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#147}::{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#149}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#149}::{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#149}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#149}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#149}::{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#151}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#151}::{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#151}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#151}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#151}::{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#153}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#153}::{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#153}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#153}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#153}::{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#155}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#155}::{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#155}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#155}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#155}::{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#157}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#157}::{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#157}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#157}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#157}::{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#159}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#159}::{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#159}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#159}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#159}::{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#161}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#161}::{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#161}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#161}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#161}::{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#163}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#163}::{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#163}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#163}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#163}::{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#165}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#165}::{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#165}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#165}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#165}::{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#167}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#167}::{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#167}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#167}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#167}::{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#169}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#169}::{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#169}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#169}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#169}::{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#171}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#171}::{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#171}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#171}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#171}::{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#173}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#173}::{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#173}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#173}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#173}::{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#175}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#175}::{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#175}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#175}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#175}::{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#177}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#177}::{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#177}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#177}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#177}::{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#179}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#179}::{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#179}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#179}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#179}::{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#181}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#181}::{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#181}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#181}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#181}::{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#183}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#183}::{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#183}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#183}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#183}::{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#185}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#185}::{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#185}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#185}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#185}::{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#187}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#187}::{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#187}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#187}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#187}::{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#189}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#189}::{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#189}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#189}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#189}::{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#191}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#191}::{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#191}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#191}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#191}::{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#193}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#193}::{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#193}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#193}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#193}::{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#195}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#195}::{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#195}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#195}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#195}::{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#197}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#197}::{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#197}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#197}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#197}::{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#199}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#199}::{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#199}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#199}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#199}::{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#201}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#201}::{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#201}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#201}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#201}::{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#203}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#203}::{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#203}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#203}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#203}::{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#205}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#205}::{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#205}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#205}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#205}::{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#207}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#207}::{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#207}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#207}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#207}::{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#209}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#209}::{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#209}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#209}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#209}::{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#211}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#211}::{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#211}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#211}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#211}::{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#213}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#213}::{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#213}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#213}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#213}::{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#215}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#215}::{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#215}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#215}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#215}::{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#217}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#217}::{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#217}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#217}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#217}::{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#219}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#219}::{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#219}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#219}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#219}::{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#221}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#221}::{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#221}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#221}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#221}::{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#223}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#223}::{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#223}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#223}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#223}::{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#225}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#225}::{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#225}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#225}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#225}::{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#227}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#227}::{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#227}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#227}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#227}::{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#229}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#229}::{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#229}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#229}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#229}::{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#231}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#231}::{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#231}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#231}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#231}::{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#233}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#233}::{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#233}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#233}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#233}::{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#235}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#235}::{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#235}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#235}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#235}::{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#237}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#237}::{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#237}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#237}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#237}::{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#239}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#239}::{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#239}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#239}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#239}::{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#241}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#241}::{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#241}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#241}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#241}::{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#243}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#243}::{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#243}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#243}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#243}::{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#245}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#245}::{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#245}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#245}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#245}::{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#247}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#247}::{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#247}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#247}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#247}::{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#249}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#249}::{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#249}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#249}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#249}::{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#251}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#251}::{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#251}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#251}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#251}::{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#253}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#253}::{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#253}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#253}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#253}::{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#255}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#255}::{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#255}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#255}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#255}::{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#257}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#257}::{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#257}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#257}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#257}::{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#259}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#259}::{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#259}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#259}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#259}::{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#261}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#261}::{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#261}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#261}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#261}::{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#263}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#263}::{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#263}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#263}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#263}::{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#265}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#265}::{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#265}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#265}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#265}::{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#267}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#267}::{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#267}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#267}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#267}::{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#269}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#269}::{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#269}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#269}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#269}::{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#271}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#271}::{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#271}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#271}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#271}::{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#273}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#273}::{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#273}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#273}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#273}::{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#275}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#275}::{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#275}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#275}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#275}::{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#277}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#277}::{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#277}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#277}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#277}::{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#279}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#279}::{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#279}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#279}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#279}::{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#281}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#281}::{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#281}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#281}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#281}::{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#283}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#283}::{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#283}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#283}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#283}::{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#285}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#285}::{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#285}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#285}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#285}::{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#287}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#287}::{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#287}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#287}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#287}::{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#289}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#289}::{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#289}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#289}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#289}::{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#291}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#291}::{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#291}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#291}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#291}::{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#293}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#293}::{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#293}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#293}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#293}::{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#295}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#295}::{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#295}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#295}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#295}::{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#297}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#297}::{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#297}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#297}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#297}::{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#299}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#299}::{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#299}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#299}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#299}::{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#301}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#301}::{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#301}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#301}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#301}::{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#303}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#303}::{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#303}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#303}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#303}::{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#305}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#305}::{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#305}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#305}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#305}::{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#307}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#307}::{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#307}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#307}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#307}::{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#309}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#309}::{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#309}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#309}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#309}::{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#311}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#311}::{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#311}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#311}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#311}::{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#313}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#313}::{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#313}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#313}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#313}::{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#315}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#315}::{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#315}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#315}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#315}::{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#317}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#317}::{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#317}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#317}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#317}::{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#319}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#319}::{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#319}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#319}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#319}::{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#321}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#321}::{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#321}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#321}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#321}::{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#323}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#323}::{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#323}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#323}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#323}::{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#325}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#325}::{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#325}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#325}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#325}::{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#327}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#327}::{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#327}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#327}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#327}::{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#329}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#329}::{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#329}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#329}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#329}::{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#331}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#331}::{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#331}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#331}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#331}::{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#333}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#333}::{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#333}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#333}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#333}::{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#335}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#335}::{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#335}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#335}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#335}::{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#337}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#337}::{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#337}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#337}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#337}::{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#339}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#339}::{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#339}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#339}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#339}::{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#341}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#341}::{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#341}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#341}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#341}::{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#343}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#343}::{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#343}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#343}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#343}::{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#345}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#345}::{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#345}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#345}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#345}::{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#347}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#347}::{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#347}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#347}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#347}::{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#349}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#349}::{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#349}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#349}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#349}::{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#351}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#351}::{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#351}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#351}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#351}::{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#353}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#353}::{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#353}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#353}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#353}::{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#355}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#355}::{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#355}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#355}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#355}::{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#357}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#357}::{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#357}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#357}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#357}::{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#359}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#359}::{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#359}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#359}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#359}::{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#361}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#361}::{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#361}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#361}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#361}::{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#363}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#363}::{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#363}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#363}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#363}::{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#365}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#365}::{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#365}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#365}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#365}::{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#367}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#367}::{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#367}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#367}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#367}::{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#369}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#369}::{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#369}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#369}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#369}::{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#47}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#47}::{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#47}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#47}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#47}::{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#52}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#52}::{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#52}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#52}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#52}::{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#57}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#57}::{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#57}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#57}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#57}::{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#62}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#62}::{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#62}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#62}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#62}::{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#67}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#67}::{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#67}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#67}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#67}::{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#72}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#72}::{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#72}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#72}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#72}::{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#77}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#77}::{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#77}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#77}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#77}::{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#82}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#82}::{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#82}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#82}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#82}::{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#87}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#87}::{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#87}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#87}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#87}::{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#92}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#92}::{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#92}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#92}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#92}::{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#97}::{constant#0}>> for Uint<crypto_bigint::::uint::{impl#97}::{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#97}::concat_mixed::{constant#0}>, ) -> <Uint<crypto_bigint::::uint::{impl#97}::{constant#1}> as ConcatMixed<Uint<crypto_bigint::::uint::{impl#97}::{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.

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<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<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<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, 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<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> 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> 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<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<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> 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> 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> 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#85}::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#90}::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#50}::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#95}::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#145}::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#100}::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#105}::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#55}::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#110}::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#115}::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#60}::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#120}::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#125}::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#130}::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#65}::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#135}::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#70}::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#75}::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#140}::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#80}::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#104}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#104}::{constant#1}>> for Uint<crypto_bigint::::uint::U2048::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#104}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#104}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#109}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#109}::{constant#1}>> for Uint<crypto_bigint::::uint::U3072::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#109}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#109}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#114}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#114}::{constant#1}>> for Uint<crypto_bigint::::uint::U3584::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#114}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#114}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#119}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#119}::{constant#1}>> for Uint<crypto_bigint::::uint::U4096::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#119}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#119}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#124}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#124}::{constant#1}>> for Uint<crypto_bigint::::uint::U4224::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#124}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#124}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#129}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#129}::{constant#1}>> for Uint<crypto_bigint::::uint::U4352::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#129}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#129}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#134}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#134}::{constant#1}>> for Uint<crypto_bigint::::uint::U6144::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#134}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#134}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#139}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#139}::{constant#1}>> for Uint<crypto_bigint::::uint::U8192::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#139}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#139}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#144}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#144}::{constant#1}>> for Uint<crypto_bigint::::uint::U16384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#144}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#144}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#148}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#148}::{constant#1}>> for Uint<crypto_bigint::::uint::U192::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#148}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#148}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#150}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#150}::{constant#1}>> for Uint<crypto_bigint::::uint::U192::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#150}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#150}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#152}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#152}::{constant#1}>> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#152}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#152}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#154}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#154}::{constant#1}>> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#154}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#154}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#156}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#156}::{constant#1}>> for Uint<crypto_bigint::::uint::U320::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#156}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#156}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#158}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#158}::{constant#1}>> for Uint<crypto_bigint::::uint::U320::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#158}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#158}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#160}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#160}::{constant#1}>> for Uint<crypto_bigint::::uint::U320::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#160}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#160}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#162}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#162}::{constant#1}>> for Uint<crypto_bigint::::uint::U320::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#162}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#162}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#164}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#164}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#164}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#164}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#166}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#166}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#166}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#166}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#168}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#168}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#168}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#168}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#170}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#170}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#170}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#170}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#172}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#172}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#172}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#172}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#174}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#174}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#174}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#174}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#176}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#176}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#176}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#176}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#178}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#178}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#178}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#178}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#180}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#180}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#180}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#180}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#182}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#182}::{constant#1}>> for Uint<crypto_bigint::::uint::U448::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#182}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#182}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#184}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#184}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#184}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#184}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#186}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#186}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#186}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#186}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#188}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#188}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#188}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#188}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#190}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#190}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#190}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#190}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#192}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#192}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#192}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#192}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#194}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#194}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#194}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#194}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#196}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#196}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#196}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#196}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#198}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#198}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#198}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#198}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#200}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#200}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#200}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#200}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#202}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#202}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#202}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#202}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#204}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#204}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#204}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#204}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#206}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#206}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#206}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#206}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#208}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#208}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#208}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#208}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#210}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#210}::{constant#1}>> for Uint<crypto_bigint::::uint::U576::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#210}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#210}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#212}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#212}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#212}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#212}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#214}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#214}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#214}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#214}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#216}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#216}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#216}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#216}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#218}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#218}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#218}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#218}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#220}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#220}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#220}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#220}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#222}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#222}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#222}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#222}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#224}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#224}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#224}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#224}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#226}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#226}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#226}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#226}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#228}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#228}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#228}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#228}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#230}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#230}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#230}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#230}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#232}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#232}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#232}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#232}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#234}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#234}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#234}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#234}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#236}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#236}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#236}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#236}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#238}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#238}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#238}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#238}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#240}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#240}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#240}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#240}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#242}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#242}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#242}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#242}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#244}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#244}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#244}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#244}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#246}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#246}::{constant#1}>> for Uint<crypto_bigint::::uint::U704::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#246}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#246}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#248}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#248}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#248}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#248}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#250}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#250}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#250}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#250}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#252}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#252}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#252}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#252}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#254}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#254}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#254}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#254}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#256}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#256}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#256}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#256}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#258}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#258}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#258}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#258}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#260}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#260}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#260}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#260}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#262}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#262}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#262}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#262}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#264}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#264}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#264}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#264}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#266}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#266}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#266}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#266}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#268}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#268}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#268}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#268}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#270}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#270}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#270}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#270}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#272}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#272}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#272}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#272}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#274}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#274}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#274}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#274}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#276}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#276}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#276}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#276}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#278}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#278}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#278}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#278}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#280}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#280}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#280}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#280}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#282}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#282}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#282}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#282}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#284}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#284}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#284}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#284}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#286}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#286}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#286}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#286}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#288}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#288}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#288}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#288}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#290}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#290}::{constant#1}>> for Uint<crypto_bigint::::uint::U832::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#290}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#290}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#292}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#292}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#292}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#292}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#294}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#294}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#294}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#294}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#296}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#296}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#296}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#296}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#298}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#298}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#298}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#298}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#300}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#300}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#300}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#300}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#302}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#302}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#302}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#302}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#304}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#304}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#304}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#304}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#306}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#306}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#306}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#306}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#308}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#308}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#308}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#308}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#310}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#310}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#310}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#310}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#312}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#312}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#312}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#312}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#314}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#314}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#314}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#314}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#316}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#316}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#316}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#316}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#318}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#318}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#318}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#318}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#320}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#320}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#320}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#320}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#322}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#322}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#322}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#322}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#324}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#324}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#324}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#324}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#326}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#326}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#326}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#326}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#328}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#328}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#328}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#328}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#330}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#330}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#330}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#330}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#332}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#332}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#332}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#332}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#334}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#334}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#334}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#334}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#336}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#336}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#336}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#336}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#338}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#338}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#338}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#338}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#340}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#340}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#340}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#340}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#342}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#342}::{constant#1}>> for Uint<crypto_bigint::::uint::U960::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#342}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#342}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#344}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#344}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#344}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#344}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#346}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#346}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#346}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#346}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#348}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#348}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#348}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#348}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#350}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#350}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#350}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#350}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#352}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#352}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#352}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#352}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#354}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#354}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#354}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#354}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#356}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#356}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#356}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#356}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#358}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#358}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#358}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#358}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#360}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#360}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#360}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#360}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#362}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#362}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#362}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#362}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#364}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#364}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#364}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#364}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#366}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#366}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#366}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#366}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#368}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#368}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#368}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#368}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#370}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#370}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#370}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#370}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#49}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#49}::{constant#1}>> for Uint<crypto_bigint::::uint::U128::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#49}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#49}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#54}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#54}::{constant#1}>> for Uint<crypto_bigint::::uint::U256::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#54}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#54}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#59}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#59}::{constant#1}>> for Uint<crypto_bigint::::uint::U384::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#59}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#59}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#64}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#64}::{constant#1}>> for Uint<crypto_bigint::::uint::U512::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#64}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#64}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#69}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#69}::{constant#1}>> for Uint<crypto_bigint::::uint::U640::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#69}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#69}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#74}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#74}::{constant#1}>> for Uint<crypto_bigint::::uint::U768::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#74}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#74}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#79}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#79}::{constant#1}>> for Uint<crypto_bigint::::uint::U896::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#79}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#79}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#84}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#84}::{constant#1}>> for Uint<crypto_bigint::::uint::U1024::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#84}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#84}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#89}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#89}::{constant#1}>> for Uint<crypto_bigint::::uint::U1280::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#89}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#89}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#94}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#94}::{constant#1}>> for Uint<crypto_bigint::::uint::U1536::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#94}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#94}::split_mixed::{constant#1}>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<crypto_bigint::::uint::{impl#99}::{constant#0}>, Uint<crypto_bigint::::uint::{impl#99}::{constant#1}>> for Uint<crypto_bigint::::uint::U1792::{constant#0}>

fn split_mixed( &self, ) -> (Uint<crypto_bigint::::uint::{impl#99}::split_mixed::{constant#0}>, Uint<crypto_bigint::::uint::{impl#99}::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>

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